]> 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
Added GetCount, GetCountRGB, and GetCountColour methods to
[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_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652 wxPyCBInputStream_copy,
1653
1654 wxPyInstance_Check,
1655 wxPySwigInstance_Check,
1656
1657 wxPyCheckForApp
1658
1659 };
1660
1661 #endif
1662
1663
1664 #if !WXWIN_COMPATIBILITY_2_4
1665 #define wxHIDE_READONLY 0
1666 #endif
1667
1668
1669 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1670 #define SWIG_From_int PyInt_FromLong
1671 /*@@*/
1672
1673
1674 #if ! wxUSE_HOTKEY
1675 enum wxHotkeyModifier
1676 {
1677 wxMOD_NONE = 0,
1678 wxMOD_ALT = 1,
1679 wxMOD_CONTROL = 2,
1680 wxMOD_SHIFT = 4,
1681 wxMOD_WIN = 8
1682 };
1683 #define wxEVT_HOTKEY 9999
1684 #endif
1685
1686 static const wxString wxPyEmptyString(wxEmptyString);
1687 static wxString wxObject_GetClassName(wxObject *self){
1688 return self->GetClassInfo()->GetClassName();
1689 }
1690 static void wxObject_Destroy(wxObject *self){
1691 delete self;
1692 }
1693
1694 #ifndef __WXMAC__
1695 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1696 #endif
1697
1698
1699 #include <limits.h>
1700
1701
1702 SWIGINTERN int
1703 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1704 const char *errmsg)
1705 {
1706 if (value < min_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is less than '%s' minimum %ld",
1710 value, errmsg, min_value);
1711 }
1712 return 0;
1713 } else if (value > max_value) {
1714 if (errmsg) {
1715 PyErr_Format(PyExc_OverflowError,
1716 "value %ld is greater than '%s' maximum %ld",
1717 value, errmsg, max_value);
1718 }
1719 return 0;
1720 }
1721 return 1;
1722 }
1723
1724
1725 SWIGINTERN int
1726 SWIG_AsVal_long(PyObject* obj, long* val)
1727 {
1728 if (PyNumber_Check(obj)) {
1729 if (val) *val = PyInt_AsLong(obj);
1730 return 1;
1731 }
1732 else {
1733 SWIG_type_error("number", obj);
1734 }
1735 return 0;
1736 }
1737
1738
1739 #if INT_MAX != LONG_MAX
1740 SWIGINTERN int
1741 SWIG_AsVal_int(PyObject *obj, int *val)
1742 {
1743 const char* errmsg = val ? "int" : (char*)0;
1744 long v;
1745 if (SWIG_AsVal_long(obj, &v)) {
1746 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1747 if (val) *val = (int)(v);
1748 return 1;
1749 } else {
1750 return 0;
1751 }
1752 } else {
1753 PyErr_Clear();
1754 }
1755 if (val) {
1756 SWIG_type_error(errmsg, obj);
1757 }
1758 return 0;
1759 }
1760 #else
1761 SWIGINTERNSHORT int
1762 SWIG_AsVal_int(PyObject *obj, int *val)
1763 {
1764 return SWIG_AsVal_long(obj,(long*)val);
1765 }
1766 #endif
1767
1768
1769 SWIGINTERNSHORT int
1770 SWIG_As_int(PyObject* obj)
1771 {
1772 int v;
1773 if (!SWIG_AsVal_int(obj, &v)) {
1774 /*
1775 this is needed to make valgrind/purify happier.
1776 */
1777 memset((void*)&v, 0, sizeof(int));
1778 }
1779 return v;
1780 }
1781
1782
1783 SWIGINTERNSHORT int
1784 SWIG_Check_int(PyObject* obj)
1785 {
1786 return SWIG_AsVal_int(obj, (int*)0);
1787 }
1788
1789 static PyObject *wxSize_Get(wxSize *self){
1790 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1791 PyObject* tup = PyTuple_New(2);
1792 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1793 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1794 wxPyEndBlockThreads(blocked);
1795 return tup;
1796 }
1797
1798 SWIGINTERN int
1799 SWIG_AsVal_double(PyObject *obj, double* val)
1800 {
1801 if (PyNumber_Check(obj)) {
1802 if (val) *val = PyFloat_AsDouble(obj);
1803 return 1;
1804 }
1805 else {
1806 SWIG_type_error("number", obj);
1807 }
1808 return 0;
1809 }
1810
1811
1812 SWIGINTERNSHORT double
1813 SWIG_As_double(PyObject* obj)
1814 {
1815 double v;
1816 if (!SWIG_AsVal_double(obj, &v)) {
1817 /*
1818 this is needed to make valgrind/purify happier.
1819 */
1820 memset((void*)&v, 0, sizeof(double));
1821 }
1822 return v;
1823 }
1824
1825
1826 SWIGINTERNSHORT int
1827 SWIG_Check_double(PyObject* obj)
1828 {
1829 return SWIG_AsVal_double(obj, (double*)0);
1830 }
1831
1832
1833 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1834 #define SWIG_From_double PyFloat_FromDouble
1835 /*@@*/
1836
1837 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1838 self->x = x;
1839 self->y = y;
1840 }
1841 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1843 PyObject* tup = PyTuple_New(2);
1844 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1845 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1846 wxPyEndBlockThreads(blocked);
1847 return tup;
1848 }
1849
1850 SWIGINTERNSHORT long
1851 SWIG_As_long(PyObject* obj)
1852 {
1853 long v;
1854 if (!SWIG_AsVal_long(obj, &v)) {
1855 /*
1856 this is needed to make valgrind/purify happier.
1857 */
1858 memset((void*)&v, 0, sizeof(long));
1859 }
1860 return v;
1861 }
1862
1863
1864 SWIGINTERNSHORT int
1865 SWIG_Check_long(PyObject* obj)
1866 {
1867 return SWIG_AsVal_long(obj, (long*)0);
1868 }
1869
1870 static void wxPoint_Set(wxPoint *self,long x,long y){
1871 self->x = x;
1872 self->y = y;
1873 }
1874 static PyObject *wxPoint_Get(wxPoint *self){
1875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1876 PyObject* tup = PyTuple_New(2);
1877 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1878 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1879 wxPyEndBlockThreads(blocked);
1880 return tup;
1881 }
1882 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1883 self->x = x;
1884 self->y = y;
1885 self->width = width;
1886 self->height = height;
1887 }
1888 static PyObject *wxRect_Get(wxRect *self){
1889 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1890 PyObject* tup = PyTuple_New(4);
1891 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1892 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1893 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1894 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1895 wxPyEndBlockThreads(blocked);
1896 return tup;
1897 }
1898
1899 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1900 wxRegion reg1(*r1);
1901 wxRegion reg2(*r2);
1902 wxRect dest(0,0,0,0);
1903 PyObject* obj;
1904
1905 reg1.Intersect(reg2);
1906 dest = reg1.GetBox();
1907
1908 if (dest != wxRect(0,0,0,0)) {
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 wxRect* newRect = new wxRect(dest);
1911 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1912 wxPyEndBlockThreads(blocked);
1913 return obj;
1914 }
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918
1919
1920 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1921 PyObject* o2;
1922 PyObject* o3;
1923
1924 if (!target) {
1925 target = o;
1926 } else if (target == Py_None) {
1927 Py_DECREF(Py_None);
1928 target = o;
1929 } else {
1930 if (!PyTuple_Check(target)) {
1931 o2 = target;
1932 target = PyTuple_New(1);
1933 PyTuple_SetItem(target, 0, o2);
1934 }
1935 o3 = PyTuple_New(1);
1936 PyTuple_SetItem(o3, 0, o);
1937
1938 o2 = target;
1939 target = PySequence_Concat(o2, o3);
1940 Py_DECREF(o2);
1941 Py_DECREF(o3);
1942 }
1943 return target;
1944 }
1945
1946
1947 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1948 self->m_x = x;
1949 self->m_y = y;
1950 }
1951 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1953 PyObject* tup = PyTuple_New(2);
1954 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1955 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1956 wxPyEndBlockThreads(blocked);
1957 return tup;
1958 }
1959
1960 #include "wx/wxPython/pyistream.h"
1961
1962 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1963 wxInputStream* wxis = wxPyCBInputStream::create(p);
1964 if (wxis)
1965 return new wxPyInputStream(wxis);
1966 else
1967 return NULL;
1968 }
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_char(char c)
1972 {
1973 return PyString_FromStringAndSize(&c,1);
1974 }
1975
1976
1977 SWIGINTERNSHORT PyObject*
1978 SWIG_From_unsigned_SS_long(unsigned long value)
1979 {
1980 return (value > LONG_MAX) ?
1981 PyLong_FromUnsignedLong(value)
1982 : PyInt_FromLong((long)(value));
1983 }
1984
1985
1986 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1987 SWIGINTERN int
1988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1989 {
1990 static swig_type_info* pchar_info = 0;
1991 char* vptr = 0;
1992 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1993 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1994 if (cptr) *cptr = vptr;
1995 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1996 return SWIG_OLDOBJ;
1997 } else {
1998 PyErr_Clear();
1999 if (PyString_Check(obj)) {
2000 if (cptr) {
2001 *cptr = PyString_AS_STRING(obj);
2002 if (psize) {
2003 *psize = PyString_GET_SIZE(obj) + 1;
2004 }
2005 }
2006 return SWIG_PYSTR;
2007 }
2008 }
2009 if (cptr) {
2010 SWIG_type_error("char *", obj);
2011 }
2012 return 0;
2013 }
2014
2015
2016 SWIGINTERN int
2017 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2018 {
2019 char* cptr; size_t csize;
2020 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2021 /* in C you can do:
2022
2023 char x[5] = "hello";
2024
2025 ie, assing the array using an extra '0' char.
2026 */
2027 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2028 if (csize <= size) {
2029 if (val) {
2030 if (csize) memcpy(val, cptr, csize);
2031 if (csize < size) memset(val + csize, 0, size - csize);
2032 }
2033 return 1;
2034 }
2035 }
2036 if (val) {
2037 PyErr_Format(PyExc_TypeError,
2038 "a char array of maximum size %lu is expected",
2039 (unsigned long) size);
2040 }
2041 return 0;
2042 }
2043
2044
2045 SWIGINTERN int
2046 SWIG_AsVal_char(PyObject *obj, char *val)
2047 {
2048 const char* errmsg = val ? "char" : (char*)0;
2049 long v;
2050 if (SWIG_AsVal_long(obj, &v)) {
2051 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2052 if (val) *val = (char)(v);
2053 return 1;
2054 } else {
2055 return 0;
2056 }
2057 } else {
2058 PyErr_Clear();
2059 return SWIG_AsCharArray(obj, val, 1);
2060 }
2061 }
2062
2063
2064 SWIGINTERNSHORT char
2065 SWIG_As_char(PyObject* obj)
2066 {
2067 char v;
2068 if (!SWIG_AsVal_char(obj, &v)) {
2069 /*
2070 this is needed to make valgrind/purify happier.
2071 */
2072 memset((void*)&v, 0, sizeof(char));
2073 }
2074 return v;
2075 }
2076
2077
2078 SWIGINTERNSHORT int
2079 SWIG_Check_char(PyObject* obj)
2080 {
2081 return SWIG_AsVal_char(obj, (char*)0);
2082 }
2083
2084
2085 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2086 #define SWIG_From_long PyInt_FromLong
2087 /*@@*/
2088
2089 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2090 // We use only strings for the streams, not unicode
2091 PyObject* str = PyObject_Str(obj);
2092 if (! str) {
2093 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2094 return;
2095 }
2096 self->Write(PyString_AS_STRING(str),
2097 PyString_GET_SIZE(str));
2098 Py_DECREF(str);
2099 }
2100
2101 #include "wx/wxPython/pyistream.h"
2102
2103
2104 class wxPyFileSystemHandler : public wxFileSystemHandler
2105 {
2106 public:
2107 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2108
2109 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2110 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2111 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2112 DEC_PYCALLBACK_STRING__pure(FindNext);
2113
2114 wxString GetProtocol(const wxString& location) {
2115 return wxFileSystemHandler::GetProtocol(location);
2116 }
2117
2118 wxString GetLeftLocation(const wxString& location) {
2119 return wxFileSystemHandler::GetLeftLocation(location);
2120 }
2121
2122 wxString GetAnchor(const wxString& location) {
2123 return wxFileSystemHandler::GetAnchor(location);
2124 }
2125
2126 wxString GetRightLocation(const wxString& location) {
2127 return wxFileSystemHandler::GetRightLocation(location);
2128 }
2129
2130 wxString GetMimeTypeFromExt(const wxString& location) {
2131 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2132 }
2133
2134 PYPRIVATE;
2135 };
2136
2137
2138 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2139 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2140 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2141 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2142
2143
2144 SWIGINTERN int
2145 SWIG_AsVal_bool(PyObject *obj, bool *val)
2146 {
2147 if (obj == Py_True) {
2148 if (val) *val = true;
2149 return 1;
2150 }
2151 if (obj == Py_False) {
2152 if (val) *val = false;
2153 return 1;
2154 }
2155 int res = 0;
2156 if (SWIG_AsVal_int(obj, &res)) {
2157 if (val) *val = res ? true : false;
2158 return 1;
2159 } else {
2160 PyErr_Clear();
2161 }
2162 if (val) {
2163 SWIG_type_error("bool", obj);
2164 }
2165 return 0;
2166 }
2167
2168
2169 SWIGINTERNSHORT bool
2170 SWIG_As_bool(PyObject* obj)
2171 {
2172 bool v;
2173 if (!SWIG_AsVal_bool(obj, &v)) {
2174 /*
2175 this is needed to make valgrind/purify happier.
2176 */
2177 memset((void*)&v, 0, sizeof(bool));
2178 }
2179 return v;
2180 }
2181
2182
2183 SWIGINTERNSHORT int
2184 SWIG_Check_bool(PyObject* obj)
2185 {
2186 return SWIG_AsVal_bool(obj, (bool*)0);
2187 }
2188
2189 static wxString FileSystem_URLToFileName(wxString const &url){
2190 wxFileName fname = wxFileSystem::URLToFileName(url);
2191 return fname.GetFullPath();
2192 }
2193
2194 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2195 wxImage& image,
2196 long type) {
2197 wxMemoryFSHandler::AddFile(filename, image, type);
2198 }
2199
2200 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2201 const wxBitmap& bitmap,
2202 long type) {
2203 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2204 }
2205
2206 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2207 PyObject* data) {
2208 if (! PyString_Check(data)) {
2209 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2210 "Expected string object"));
2211 return;
2212 }
2213
2214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2215 void* ptr = (void*)PyString_AsString(data);
2216 size_t size = PyString_Size(data);
2217 wxPyEndBlockThreads(blocked);
2218
2219 wxMemoryFSHandler::AddFile(filename, ptr, size);
2220 }
2221
2222
2223 #include "wx/wxPython/pyistream.h"
2224
2225
2226 SWIGINTERN int
2227 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2228 {
2229 long v = 0;
2230 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2231 SWIG_type_error("unsigned number", obj);
2232 }
2233 else if (val)
2234 *val = (unsigned long)v;
2235 return 1;
2236 }
2237
2238
2239 SWIGINTERNSHORT int
2240 SWIG_CheckUnsignedLongInRange(unsigned long value,
2241 unsigned long max_value,
2242 const char *errmsg)
2243 {
2244 if (value > max_value) {
2245 if (errmsg) {
2246 PyErr_Format(PyExc_OverflowError,
2247 "value %lu is greater than '%s' minimum %lu",
2248 value, errmsg, max_value);
2249 }
2250 return 0;
2251 }
2252 return 1;
2253 }
2254
2255
2256 SWIGINTERN int
2257 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2258 {
2259 const char* errmsg = val ? "unsigned char" : (char*)0;
2260 unsigned long v;
2261 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2262 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2263 if (val) *val = (unsigned char)(v);
2264 return 1;
2265 } else {
2266 return 0;
2267 }
2268 } else {
2269 PyErr_Clear();
2270 }
2271 if (val) {
2272 SWIG_type_error(errmsg, obj);
2273 }
2274 return 0;
2275 }
2276
2277
2278 SWIGINTERNSHORT unsigned char
2279 SWIG_As_unsigned_SS_char(PyObject* obj)
2280 {
2281 unsigned char v;
2282 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2283 /*
2284 this is needed to make valgrind/purify happier.
2285 */
2286 memset((void*)&v, 0, sizeof(unsigned char));
2287 }
2288 return v;
2289 }
2290
2291
2292 SWIGINTERNSHORT int
2293 SWIG_Check_unsigned_SS_char(PyObject* obj)
2294 {
2295 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2296 }
2297
2298
2299 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2300 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2301 /*@@*/
2302
2303
2304 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2305 if (width > 0 && height > 0)
2306 return new wxImage(width, height, clear);
2307 else
2308 return new wxImage;
2309 }
2310 static wxImage *new_wxImage(wxBitmap const &bitmap){
2311 return new wxImage(bitmap.ConvertToImage());
2312 }
2313 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2314 // Copy the source data so the wxImage can clean it up later
2315 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2316 if (copy == NULL) {
2317 PyErr_NoMemory();
2318 return NULL;
2319 }
2320 memcpy(copy, data, width*height*3);
2321 return new wxImage(width, height, copy, false);
2322 }
2323 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2324 // Copy the source data so the wxImage can clean it up later
2325 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2326 if (dcopy == NULL) {
2327 PyErr_NoMemory();
2328 return NULL;
2329 }
2330 memcpy(dcopy, data, width*height*3);
2331 unsigned char* acopy = (unsigned char*)malloc(width*height);
2332 if (acopy == NULL) {
2333 PyErr_NoMemory();
2334 return NULL;
2335 }
2336 memcpy(acopy, alpha, width*height);
2337
2338 return new wxImage(width, height, dcopy, acopy, false);
2339 }
2340 static wxSize wxImage_GetSize(wxImage *self){
2341 wxSize size(self->GetWidth(), self->GetHeight());
2342 return size;
2343 }
2344 static PyObject *wxImage_GetData(wxImage *self){
2345 unsigned char* data = self->GetData();
2346 int len = self->GetWidth() * self->GetHeight() * 3;
2347 PyObject* rv;
2348 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2349 return rv;
2350 }
2351 static void wxImage_SetData(wxImage *self,PyObject *data){
2352 unsigned char* dataPtr;
2353
2354 if (! PyString_Check(data)) {
2355 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2356 "Expected string object"));
2357 return /* NULL */ ;
2358 }
2359
2360 size_t len = self->GetWidth() * self->GetHeight() * 3;
2361 dataPtr = (unsigned char*) malloc(len);
2362 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2363 self->SetData(dataPtr);
2364 // wxImage takes ownership of dataPtr...
2365 }
2366 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2367 unsigned char* data = self->GetData();
2368 int len = self->GetWidth() * self->GetHeight() * 3;
2369 PyObject* rv;
2370 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2371 return rv;
2372 }
2373 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2374 unsigned char* buffer;
2375 int size;
2376
2377 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2378 if (!PyArg_Parse(data, "t#", &buffer, &size))
2379 goto done;
2380
2381 if (size != self->GetWidth() * self->GetHeight() * 3) {
2382 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2383 goto done;
2384 }
2385 self->SetData(buffer);
2386 done:
2387 wxPyEndBlockThreads(blocked);
2388 }
2389 static PyObject *wxImage_GetAlphaData(wxImage *self){
2390 unsigned char* data = self->GetAlpha();
2391 if (! data) {
2392 RETURN_NONE();
2393 } else {
2394 int len = self->GetWidth() * self->GetHeight();
2395 PyObject* rv;
2396 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2397 return rv;
2398 }
2399 }
2400 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2401 unsigned char* dataPtr;
2402
2403 if (! PyString_Check(data)) {
2404 PyErr_SetString(PyExc_TypeError, "Expected string object");
2405 return /* NULL */ ;
2406 }
2407
2408 size_t len = self->GetWidth() * self->GetHeight();
2409 dataPtr = (unsigned char*) malloc(len);
2410 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2411 self->SetAlpha(dataPtr);
2412 // wxImage takes ownership of dataPtr...
2413 }
2414 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2415 unsigned char* data = self->GetAlpha();
2416 int len = self->GetWidth() * self->GetHeight();
2417 PyObject* rv;
2418 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2419 return rv;
2420 }
2421 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2422 unsigned char* buffer;
2423 int size;
2424
2425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2426 if (!PyArg_Parse(data, "t#", &buffer, &size))
2427 goto done;
2428
2429 if (size != self->GetWidth() * self->GetHeight()) {
2430 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2431 goto done;
2432 }
2433 self->SetAlpha(buffer);
2434 done:
2435 wxPyEndBlockThreads(blocked);
2436 }
2437
2438 SWIGINTERNSHORT unsigned long
2439 SWIG_As_unsigned_SS_long(PyObject* obj)
2440 {
2441 unsigned long v;
2442 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2443 /*
2444 this is needed to make valgrind/purify happier.
2445 */
2446 memset((void*)&v, 0, sizeof(unsigned long));
2447 }
2448 return v;
2449 }
2450
2451
2452 SWIGINTERNSHORT int
2453 SWIG_Check_unsigned_SS_long(PyObject* obj)
2454 {
2455 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2456 }
2457
2458 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2459 wxBitmap bitmap(*self, depth);
2460 return bitmap;
2461 }
2462 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2463 wxImage mono = self->ConvertToMono( red, green, blue );
2464 wxBitmap bitmap( mono, 1 );
2465 return bitmap;
2466 }
2467 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2468 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2470 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2474 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2475 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2476 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2477 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2478 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2479 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2480 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2481 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2482
2483 #include <wx/quantize.h>
2484
2485 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2486 return wxQuantize::Quantize(src, dest,
2487 //NULL, // palette
2488 desiredNoColours,
2489 NULL, // eightBitData
2490 flags);
2491 }
2492 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2493 if (PyCallable_Check(func)) {
2494 self->Connect(id, lastId, eventType,
2495 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2496 new wxPyCallback(func));
2497 }
2498 else if (func == Py_None) {
2499 self->Disconnect(id, lastId, eventType,
2500 (wxObjectEventFunction)
2501 &wxPyCallback::EventThunker);
2502 }
2503 else {
2504 wxPyBLOCK_THREADS(
2505 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2506 }
2507 }
2508 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2509 return self->Disconnect(id, lastId, eventType,
2510 (wxObjectEventFunction)
2511 &wxPyCallback::EventThunker);
2512 }
2513 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2514 if (_self && _self != Py_None) {
2515 self->SetClientObject(new wxPyOORClientData(_self, incref));
2516 }
2517 else {
2518 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2519 if (data) {
2520 self->SetClientObject(NULL); // This will delete it too
2521 }
2522 }
2523 }
2524
2525 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2526 #if wxUSE_UNICODE
2527 return self->GetUnicodeKey();
2528 #else
2529 return 0;
2530 #endif
2531 }
2532
2533 #if UINT_MAX < LONG_MAX
2534 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_long
2536 /*@@*/
2537 #else
2538 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2539 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2540 /*@@*/
2541 #endif
2542
2543
2544 #if UINT_MAX != ULONG_MAX
2545 SWIGINTERN int
2546 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2547 {
2548 const char* errmsg = val ? "unsigned int" : (char*)0;
2549 unsigned long v;
2550 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2551 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2552 if (val) *val = (unsigned int)(v);
2553 return 1;
2554 }
2555 } else {
2556 PyErr_Clear();
2557 }
2558 if (val) {
2559 SWIG_type_error(errmsg, obj);
2560 }
2561 return 0;
2562 }
2563 #else
2564 SWIGINTERNSHORT unsigned int
2565 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2566 {
2567 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2568 }
2569 #endif
2570
2571
2572 SWIGINTERNSHORT unsigned int
2573 SWIG_As_unsigned_SS_int(PyObject* obj)
2574 {
2575 unsigned int v;
2576 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2577 /*
2578 this is needed to make valgrind/purify happier.
2579 */
2580 memset((void*)&v, 0, sizeof(unsigned int));
2581 }
2582 return v;
2583 }
2584
2585
2586 SWIGINTERNSHORT int
2587 SWIG_Check_unsigned_SS_int(PyObject* obj)
2588 {
2589 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2590 }
2591
2592 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2593 self->m_size = size;
2594 }
2595 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2596 int count = self->GetNumberOfFiles();
2597 wxString* files = self->GetFiles();
2598 PyObject* list = PyList_New(count);
2599
2600 if (!list) {
2601 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2602 return NULL;
2603 }
2604
2605 for (int i=0; i<count; i++) {
2606 PyList_SetItem(list, i, wx2PyString(files[i]));
2607 }
2608 return list;
2609 }
2610
2611
2612 static wxPyApp *new_wxPyApp(){
2613 wxPythonApp = new wxPyApp();
2614 return wxPythonApp;
2615 }
2616
2617 void wxApp_CleanUp() {
2618 __wxPyCleanup();
2619 }
2620
2621
2622 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2623
2624
2625 SWIGINTERNSHORT int
2626 SWIG_AsCharPtr(PyObject *obj, char **val)
2627 {
2628 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2629 return 1;
2630 }
2631 if (val) {
2632 PyErr_Clear();
2633 SWIG_type_error("char *", obj);
2634 }
2635 return 0;
2636 }
2637
2638
2639 SWIGINTERN PyObject *
2640 SWIG_FromCharPtr(const char* cptr)
2641 {
2642 if (cptr) {
2643 size_t size = strlen(cptr);
2644 if (size > INT_MAX) {
2645 return SWIG_NewPointerObj((char*)(cptr),
2646 SWIG_TypeQuery("char *"), 0);
2647 } else {
2648 if (size != 0) {
2649 return PyString_FromStringAndSize(cptr, size);
2650 } else {
2651 return PyString_FromString(cptr);
2652 }
2653 }
2654 }
2655 Py_INCREF(Py_None);
2656 return Py_None;
2657 }
2658
2659
2660 #ifdef __WXMAC__
2661
2662 // A dummy class that raises an exception if used...
2663 class wxEventLoop
2664 {
2665 public:
2666 wxEventLoop() { wxPyRaiseNotImplemented(); }
2667 int Run() { return 0; }
2668 void Exit(int rc = 0) {}
2669 bool Pending() const { return false; }
2670 bool Dispatch() { return false; }
2671 bool IsRunning() const { return false; }
2672 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2673 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2674 };
2675
2676 #else
2677
2678 #include <wx/evtloop.h>
2679
2680 #endif
2681
2682
2683
2684 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2685 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2686 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2687 static PyObject *wxWindow_GetChildren(wxWindow *self){
2688 wxWindowList& list = self->GetChildren();
2689 return wxPy_ConvertList(&list);
2690 }
2691 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2692 #if wxUSE_HOTKEY
2693 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2694 #else
2695 return false;
2696 #endif
2697 }
2698 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2699
2700
2701
2702 return false;
2703
2704 }
2705 static long wxWindow_GetHandle(wxWindow *self){
2706 return wxPyGetWinHandle(self);
2707 }
2708 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2709 self->AssociateHandle((WXWidget)handle);
2710 }
2711
2712 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2713 return wxWindow::FindWindowById(id, parent);
2714 }
2715
2716 wxWindow* wxFindWindowByName( const wxString& name,
2717 const wxWindow *parent = NULL ) {
2718 return wxWindow::FindWindowByName(name, parent);
2719 }
2720
2721 wxWindow* wxFindWindowByLabel( const wxString& label,
2722 const wxWindow *parent = NULL ) {
2723 return wxWindow::FindWindowByLabel(label, parent);
2724 }
2725
2726
2727 #ifdef __WXMSW__
2728 #include <wx/msw/private.h> // to get wxGetWindowId
2729 #endif
2730
2731
2732 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2733 #ifdef __WXMSW__
2734 WXHWND hWnd = (WXHWND)_hWnd;
2735 long id = wxGetWindowId(hWnd);
2736 wxWindow* win = new wxWindow;
2737 parent->AddChild(win);
2738 win->SetEventHandler(win);
2739 win->SetHWND(hWnd);
2740 win->SetId(id);
2741 win->SubclassWin(hWnd);
2742 win->AdoptAttributesFromHWND();
2743 win->SetupColours();
2744 return win;
2745 #else
2746 wxPyRaiseNotImplemented();
2747 return NULL;
2748 #endif
2749 }
2750
2751
2752 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2753 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2754 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2755
2756 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2757
2758 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2759 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2760 wxMenuItemList& list = self->GetMenuItems();
2761 return wxPy_ConvertList(&list);
2762 }
2763 static const wxString wxPyControlNameStr(wxControlNameStr);
2764 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2765 if (clientData) {
2766 wxPyClientData* data = new wxPyClientData(clientData);
2767 return self->Append(item, data);
2768 } else
2769 return self->Append(item);
2770 }
2771 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2772 if (clientData) {
2773 wxPyClientData* data = new wxPyClientData(clientData);
2774 return self->Insert(item, pos, data);
2775 } else
2776 return self->Insert(item, pos);
2777 }
2778 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2779 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2780 if (data) {
2781 Py_INCREF(data->m_obj);
2782 return data->m_obj;
2783 } else {
2784 Py_INCREF(Py_None);
2785 return Py_None;
2786 }
2787 }
2788 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2789 wxPyClientData* data = new wxPyClientData(clientData);
2790 self->SetClientObject(n, data);
2791 }
2792
2793
2794 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2795 wxPyUserData* data = NULL;
2796 if ( userData ) {
2797 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2798 data = new wxPyUserData(userData);
2799 wxPyEndBlockThreads(blocked);
2800 }
2801 return new wxSizerItem(window, proportion, flag, border, data);
2802 }
2803 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2804 wxPyUserData* data = NULL;
2805 if ( userData ) {
2806 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2807 data = new wxPyUserData(userData);
2808 wxPyEndBlockThreads(blocked);
2809 }
2810 return new wxSizerItem(width, height, proportion, flag, border, data);
2811 }
2812 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2813 wxPyUserData* data = NULL;
2814 if ( userData ) {
2815 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2816 data = new wxPyUserData(userData);
2817 wxPyEndBlockThreads(blocked);
2818 }
2819 return new wxSizerItem(sizer, proportion, flag, border, data);
2820 }
2821
2822 #include <float.h>
2823 SWIGINTERN int
2824 SWIG_CheckDoubleInRange(double value, double min_value,
2825 double max_value, const char* errmsg)
2826 {
2827 if (value < min_value) {
2828 if (errmsg) {
2829 PyErr_Format(PyExc_OverflowError,
2830 "value %g is less than %s minimum %g",
2831 value, errmsg, min_value);
2832 }
2833 return 0;
2834 } else if (value > max_value) {
2835 if (errmsg) {
2836 PyErr_Format(PyExc_OverflowError,
2837 "value %g is greater than %s maximum %g",
2838 value, errmsg, max_value);
2839 }
2840 return 0;
2841 }
2842 return 1;
2843 }
2844
2845
2846 SWIGINTERN int
2847 SWIG_AsVal_float(PyObject *obj, float *val)
2848 {
2849 const char* errmsg = val ? "float" : (char*)0;
2850 double v;
2851 if (SWIG_AsVal_double(obj, &v)) {
2852 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2853 if (val) *val = (float)(v);
2854 return 1;
2855 } else {
2856 return 0;
2857 }
2858 } else {
2859 PyErr_Clear();
2860 }
2861 if (val) {
2862 SWIG_type_error(errmsg, obj);
2863 }
2864 return 0;
2865 }
2866
2867
2868 SWIGINTERNSHORT float
2869 SWIG_As_float(PyObject* obj)
2870 {
2871 float v;
2872 if (!SWIG_AsVal_float(obj, &v)) {
2873 /*
2874 this is needed to make valgrind/purify happier.
2875 */
2876 memset((void*)&v, 0, sizeof(float));
2877 }
2878 return v;
2879 }
2880
2881
2882 SWIGINTERNSHORT int
2883 SWIG_Check_float(PyObject* obj)
2884 {
2885 return SWIG_AsVal_float(obj, (float*)0);
2886 }
2887
2888
2889 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2890 #define SWIG_From_float PyFloat_FromDouble
2891 /*@@*/
2892
2893 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2894 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2895 if (data) {
2896 Py_INCREF(data->m_obj);
2897 return data->m_obj;
2898 } else {
2899 Py_INCREF(Py_None);
2900 return Py_None;
2901 }
2902 }
2903
2904 // Figure out the type of the sizer item
2905
2906 struct wxPySizerItemInfo {
2907 wxPySizerItemInfo()
2908 : window(NULL), sizer(NULL), gotSize(false),
2909 size(wxDefaultSize), gotPos(false), pos(-1)
2910 {}
2911
2912 wxWindow* window;
2913 wxSizer* sizer;
2914 bool gotSize;
2915 wxSize size;
2916 bool gotPos;
2917 int pos;
2918 };
2919
2920 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2921
2922 wxPySizerItemInfo info;
2923 wxSize size;
2924 wxSize* sizePtr = &size;
2925
2926 // Find out what the type of the item is
2927 // try wxWindow
2928 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2929 PyErr_Clear();
2930 info.window = NULL;
2931
2932 // try wxSizer
2933 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2934 PyErr_Clear();
2935 info.sizer = NULL;
2936
2937 // try wxSize or (w,h)
2938 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2939 info.size = *sizePtr;
2940 info.gotSize = true;
2941 }
2942
2943 // or a single int
2944 if (checkIdx && PyInt_Check(item)) {
2945 info.pos = PyInt_AsLong(item);
2946 info.gotPos = true;
2947 }
2948 }
2949 }
2950
2951 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2952 // no expected type, figure out what kind of error message to generate
2953 if ( !checkSize && !checkIdx )
2954 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2955 else if ( checkSize && !checkIdx )
2956 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2957 else if ( !checkSize && checkIdx)
2958 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2959 else
2960 // can this one happen?
2961 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2962 }
2963
2964 return info;
2965 }
2966
2967 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2968 if (!self->GetClientObject())
2969 self->SetClientObject(new wxPyOORClientData(_self));
2970 }
2971 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2972
2973 wxPyUserData* data = NULL;
2974 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2975 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2976 if ( userData && (info.window || info.sizer || info.gotSize) )
2977 data = new wxPyUserData(userData);
2978 wxPyEndBlockThreads(blocked);
2979
2980 // Now call the real Add method if a valid item type was found
2981 if ( info.window )
2982 return self->Add(info.window, proportion, flag, border, data);
2983 else if ( info.sizer )
2984 return self->Add(info.sizer, proportion, flag, border, data);
2985 else if (info.gotSize)
2986 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2987 proportion, flag, border, data);
2988 else
2989 return NULL;
2990 }
2991 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2992
2993 wxPyUserData* data = NULL;
2994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2995 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2996 if ( userData && (info.window || info.sizer || info.gotSize) )
2997 data = new wxPyUserData(userData);
2998 wxPyEndBlockThreads(blocked);
2999
3000 // Now call the real Insert method if a valid item type was found
3001 if ( info.window )
3002 return self->Insert(before, info.window, proportion, flag, border, data);
3003 else if ( info.sizer )
3004 return self->Insert(before, info.sizer, proportion, flag, border, data);
3005 else if (info.gotSize)
3006 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3007 proportion, flag, border, data);
3008 else
3009 return NULL;
3010 }
3011 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3012
3013 wxPyUserData* data = NULL;
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3016 if ( userData && (info.window || info.sizer || info.gotSize) )
3017 data = new wxPyUserData(userData);
3018 wxPyEndBlockThreads(blocked);
3019
3020 // Now call the real Prepend method if a valid item type was found
3021 if ( info.window )
3022 return self->Prepend(info.window, proportion, flag, border, data);
3023 else if ( info.sizer )
3024 return self->Prepend(info.sizer, proportion, flag, border, data);
3025 else if (info.gotSize)
3026 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3027 proportion, flag, border, data);
3028 else
3029 return NULL;
3030 }
3031 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3033 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3034 wxPyEndBlockThreads(blocked);
3035 if ( info.window )
3036 return self->Remove(info.window);
3037 else if ( info.sizer )
3038 return self->Remove(info.sizer);
3039 else if ( info.gotPos )
3040 return self->Remove(info.pos);
3041 else
3042 return false;
3043 }
3044 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3046 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3047 wxPyEndBlockThreads(blocked);
3048 if ( info.window )
3049 return self->Detach(info.window);
3050 else if ( info.sizer )
3051 return self->Detach(info.sizer);
3052 else if ( info.gotPos )
3053 return self->Detach(info.pos);
3054 else
3055 return false;
3056 }
3057 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3058 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3059 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3060 wxPyEndBlockThreads(blocked);
3061 if ( info.window )
3062 return self->GetItem(info.window);
3063 else if ( info.sizer )
3064 return self->GetItem(info.sizer);
3065 else if ( info.gotPos )
3066 return self->GetItem(info.pos);
3067 else
3068 return NULL;
3069 }
3070 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3072 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3073 wxPyEndBlockThreads(blocked);
3074 if ( info.window )
3075 self->SetItemMinSize(info.window, size);
3076 else if ( info.sizer )
3077 self->SetItemMinSize(info.sizer, size);
3078 else if ( info.gotPos )
3079 self->SetItemMinSize(info.pos, size);
3080 }
3081 static PyObject *wxSizer_GetChildren(wxSizer *self){
3082 wxSizerItemList& list = self->GetChildren();
3083 return wxPy_ConvertList(&list);
3084 }
3085 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3086 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3088 wxPyEndBlockThreads(blocked);
3089 if ( info.window )
3090 return self->Show(info.window, show, recursive);
3091 else if ( info.sizer )
3092 return self->Show(info.sizer, show, recursive);
3093 else if ( info.gotPos )
3094 return self->Show(info.pos, show);
3095 else
3096 return false;
3097 }
3098 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3099 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3100 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3101 wxPyEndBlockThreads(blocked);
3102 if ( info.window )
3103 return self->IsShown(info.window);
3104 else if ( info.sizer )
3105 return self->IsShown(info.sizer);
3106 else if ( info.gotPos )
3107 return self->IsShown(info.pos);
3108 else
3109 return false;
3110 }
3111
3112 // See pyclasses.h
3113 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3114 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3115 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3116
3117
3118
3119
3120 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3121 {
3122 if (source == Py_None) {
3123 **obj = wxGBPosition(-1,-1);
3124 return true;
3125 }
3126 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3127 }
3128
3129 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3130 {
3131 if (source == Py_None) {
3132 **obj = wxGBSpan(-1,-1);
3133 return true;
3134 }
3135 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3136 }
3137
3138
3139 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3140 self->SetRow(row);
3141 self->SetCol(col);
3142 }
3143 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3144 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3145 PyObject* tup = PyTuple_New(2);
3146 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3147 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3148 wxPyEndBlockThreads(blocked);
3149 return tup;
3150 }
3151 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3152 self->SetRowspan(rowspan);
3153 self->SetColspan(colspan);
3154 }
3155 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3157 PyObject* tup = PyTuple_New(2);
3158 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3159 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3160 wxPyEndBlockThreads(blocked);
3161 return tup;
3162 }
3163 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3164 wxPyUserData* data = NULL;
3165 if ( userData ) {
3166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3167 data = new wxPyUserData(userData);
3168 wxPyEndBlockThreads(blocked);
3169 }
3170 return new wxGBSizerItem(window, pos, span, flag, border, data);
3171 }
3172 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3173 wxPyUserData* data = NULL;
3174 if ( userData ) {
3175 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3176 data = new wxPyUserData(userData);
3177 wxPyEndBlockThreads(blocked);
3178 }
3179 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3180 }
3181 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3182 wxPyUserData* data = NULL;
3183 if ( userData ) {
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 data = new wxPyUserData(userData);
3186 wxPyEndBlockThreads(blocked);
3187 }
3188 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3189 }
3190 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3191 int row, col;
3192 self->GetEndPos(row, col);
3193 return wxGBPosition(row, col);
3194 }
3195 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3196
3197 wxPyUserData* data = NULL;
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3200 if ( userData && (info.window || info.sizer || info.gotSize) )
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203
3204 // Now call the real Add method if a valid item type was found
3205 if ( info.window )
3206 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3207 else if ( info.sizer )
3208 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3209 else if (info.gotSize)
3210 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3211 pos, span, flag, border, data);
3212 return NULL;
3213 }
3214
3215
3216 #ifdef __cplusplus
3217 extern "C" {
3218 #endif
3219 static int _wrap_EmptyString_set(PyObject *) {
3220 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3221 return 1;
3222 }
3223
3224
3225 static PyObject *_wrap_EmptyString_get(void) {
3226 PyObject *pyobj;
3227
3228 {
3229 #if wxUSE_UNICODE
3230 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3231 #else
3232 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3233 #endif
3234 }
3235 return pyobj;
3236 }
3237
3238
3239 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3240 PyObject *resultobj;
3241 wxObject *arg1 = (wxObject *) 0 ;
3242 wxString result;
3243 PyObject * obj0 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "self", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3250 if (SWIG_arg_fail(1)) SWIG_fail;
3251 {
3252 PyThreadState* __tstate = wxPyBeginAllowThreads();
3253 result = wxObject_GetClassName(arg1);
3254
3255 wxPyEndAllowThreads(__tstate);
3256 if (PyErr_Occurred()) SWIG_fail;
3257 }
3258 {
3259 #if wxUSE_UNICODE
3260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3261 #else
3262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3263 #endif
3264 }
3265 return resultobj;
3266 fail:
3267 return NULL;
3268 }
3269
3270
3271 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxObject *arg1 = (wxObject *) 0 ;
3274 PyObject * obj0 = 0 ;
3275 char *kwnames[] = {
3276 (char *) "self", NULL
3277 };
3278
3279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3281 if (SWIG_arg_fail(1)) SWIG_fail;
3282 {
3283 PyThreadState* __tstate = wxPyBeginAllowThreads();
3284 wxObject_Destroy(arg1);
3285
3286 wxPyEndAllowThreads(__tstate);
3287 if (PyErr_Occurred()) SWIG_fail;
3288 }
3289 Py_INCREF(Py_None); resultobj = Py_None;
3290 return resultobj;
3291 fail:
3292 return NULL;
3293 }
3294
3295
3296 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3297 PyObject *obj;
3298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3299 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3300 Py_INCREF(obj);
3301 return Py_BuildValue((char *)"");
3302 }
3303 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxSize *arg1 = (wxSize *) 0 ;
3306 int arg2 ;
3307 PyObject * obj0 = 0 ;
3308 PyObject * obj1 = 0 ;
3309 char *kwnames[] = {
3310 (char *) "self",(char *) "x", NULL
3311 };
3312
3313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3315 if (SWIG_arg_fail(1)) SWIG_fail;
3316 {
3317 arg2 = (int)(SWIG_As_int(obj1));
3318 if (SWIG_arg_fail(2)) SWIG_fail;
3319 }
3320 if (arg1) (arg1)->x = arg2;
3321
3322 Py_INCREF(Py_None); resultobj = Py_None;
3323 return resultobj;
3324 fail:
3325 return NULL;
3326 }
3327
3328
3329 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3330 PyObject *resultobj;
3331 wxSize *arg1 = (wxSize *) 0 ;
3332 int result;
3333 PyObject * obj0 = 0 ;
3334 char *kwnames[] = {
3335 (char *) "self", NULL
3336 };
3337
3338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3340 if (SWIG_arg_fail(1)) SWIG_fail;
3341 result = (int) ((arg1)->x);
3342
3343 {
3344 resultobj = SWIG_From_int((int)(result));
3345 }
3346 return resultobj;
3347 fail:
3348 return NULL;
3349 }
3350
3351
3352 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3353 PyObject *resultobj;
3354 wxSize *arg1 = (wxSize *) 0 ;
3355 int arg2 ;
3356 PyObject * obj0 = 0 ;
3357 PyObject * obj1 = 0 ;
3358 char *kwnames[] = {
3359 (char *) "self",(char *) "y", NULL
3360 };
3361
3362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3364 if (SWIG_arg_fail(1)) SWIG_fail;
3365 {
3366 arg2 = (int)(SWIG_As_int(obj1));
3367 if (SWIG_arg_fail(2)) SWIG_fail;
3368 }
3369 if (arg1) (arg1)->y = arg2;
3370
3371 Py_INCREF(Py_None); resultobj = Py_None;
3372 return resultobj;
3373 fail:
3374 return NULL;
3375 }
3376
3377
3378 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3379 PyObject *resultobj;
3380 wxSize *arg1 = (wxSize *) 0 ;
3381 int result;
3382 PyObject * obj0 = 0 ;
3383 char *kwnames[] = {
3384 (char *) "self", NULL
3385 };
3386
3387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3389 if (SWIG_arg_fail(1)) SWIG_fail;
3390 result = (int) ((arg1)->y);
3391
3392 {
3393 resultobj = SWIG_From_int((int)(result));
3394 }
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 int arg1 = (int) 0 ;
3404 int arg2 = (int) 0 ;
3405 wxSize *result;
3406 PyObject * obj0 = 0 ;
3407 PyObject * obj1 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "w",(char *) "h", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3413 if (obj0) {
3414 {
3415 arg1 = (int)(SWIG_As_int(obj0));
3416 if (SWIG_arg_fail(1)) SWIG_fail;
3417 }
3418 }
3419 if (obj1) {
3420 {
3421 arg2 = (int)(SWIG_As_int(obj1));
3422 if (SWIG_arg_fail(2)) SWIG_fail;
3423 }
3424 }
3425 {
3426 PyThreadState* __tstate = wxPyBeginAllowThreads();
3427 result = (wxSize *)new wxSize(arg1,arg2);
3428
3429 wxPyEndAllowThreads(__tstate);
3430 if (PyErr_Occurred()) SWIG_fail;
3431 }
3432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3433 return resultobj;
3434 fail:
3435 return NULL;
3436 }
3437
3438
3439 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3440 PyObject *resultobj;
3441 wxSize *arg1 = (wxSize *) 0 ;
3442 PyObject * obj0 = 0 ;
3443 char *kwnames[] = {
3444 (char *) "self", NULL
3445 };
3446
3447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3449 if (SWIG_arg_fail(1)) SWIG_fail;
3450 {
3451 PyThreadState* __tstate = wxPyBeginAllowThreads();
3452 delete arg1;
3453
3454 wxPyEndAllowThreads(__tstate);
3455 if (PyErr_Occurred()) SWIG_fail;
3456 }
3457 Py_INCREF(Py_None); resultobj = Py_None;
3458 return resultobj;
3459 fail:
3460 return NULL;
3461 }
3462
3463
3464 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3465 PyObject *resultobj;
3466 wxSize *arg1 = (wxSize *) 0 ;
3467 wxSize *arg2 = 0 ;
3468 bool result;
3469 wxSize temp2 ;
3470 PyObject * obj0 = 0 ;
3471 PyObject * obj1 = 0 ;
3472 char *kwnames[] = {
3473 (char *) "self",(char *) "sz", NULL
3474 };
3475
3476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3478 if (SWIG_arg_fail(1)) SWIG_fail;
3479 {
3480 arg2 = &temp2;
3481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3482 }
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 {
3491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3492 }
3493 return resultobj;
3494 fail:
3495 return NULL;
3496 }
3497
3498
3499 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3500 PyObject *resultobj;
3501 wxSize *arg1 = (wxSize *) 0 ;
3502 wxSize *arg2 = 0 ;
3503 bool result;
3504 wxSize temp2 ;
3505 PyObject * obj0 = 0 ;
3506 PyObject * obj1 = 0 ;
3507 char *kwnames[] = {
3508 (char *) "self",(char *) "sz", NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3513 if (SWIG_arg_fail(1)) SWIG_fail;
3514 {
3515 arg2 = &temp2;
3516 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3517 }
3518 {
3519 PyThreadState* __tstate = wxPyBeginAllowThreads();
3520 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3521
3522 wxPyEndAllowThreads(__tstate);
3523 if (PyErr_Occurred()) SWIG_fail;
3524 }
3525 {
3526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3527 }
3528 return resultobj;
3529 fail:
3530 return NULL;
3531 }
3532
3533
3534 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3535 PyObject *resultobj;
3536 wxSize *arg1 = (wxSize *) 0 ;
3537 wxSize *arg2 = 0 ;
3538 wxSize result;
3539 wxSize temp2 ;
3540 PyObject * obj0 = 0 ;
3541 PyObject * obj1 = 0 ;
3542 char *kwnames[] = {
3543 (char *) "self",(char *) "sz", NULL
3544 };
3545
3546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3548 if (SWIG_arg_fail(1)) SWIG_fail;
3549 {
3550 arg2 = &temp2;
3551 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3552 }
3553 {
3554 PyThreadState* __tstate = wxPyBeginAllowThreads();
3555 result = (arg1)->operator +((wxSize const &)*arg2);
3556
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 {
3561 wxSize * resultptr;
3562 resultptr = new wxSize((wxSize &)(result));
3563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3564 }
3565 return resultobj;
3566 fail:
3567 return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3572 PyObject *resultobj;
3573 wxSize *arg1 = (wxSize *) 0 ;
3574 wxSize *arg2 = 0 ;
3575 wxSize result;
3576 wxSize temp2 ;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "self",(char *) "sz", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 {
3587 arg2 = &temp2;
3588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3589 }
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 result = (arg1)->operator -((wxSize const &)*arg2);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 {
3598 wxSize * resultptr;
3599 resultptr = new wxSize((wxSize &)(result));
3600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3601 }
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 wxSize *arg1 = (wxSize *) 0 ;
3611 wxSize *arg2 = 0 ;
3612 wxSize temp2 ;
3613 PyObject * obj0 = 0 ;
3614 PyObject * obj1 = 0 ;
3615 char *kwnames[] = {
3616 (char *) "self",(char *) "sz", NULL
3617 };
3618
3619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3621 if (SWIG_arg_fail(1)) SWIG_fail;
3622 {
3623 arg2 = &temp2;
3624 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3625 }
3626 {
3627 PyThreadState* __tstate = wxPyBeginAllowThreads();
3628 (arg1)->IncTo((wxSize const &)*arg2);
3629
3630 wxPyEndAllowThreads(__tstate);
3631 if (PyErr_Occurred()) SWIG_fail;
3632 }
3633 Py_INCREF(Py_None); resultobj = Py_None;
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3641 PyObject *resultobj;
3642 wxSize *arg1 = (wxSize *) 0 ;
3643 wxSize *arg2 = 0 ;
3644 wxSize temp2 ;
3645 PyObject * obj0 = 0 ;
3646 PyObject * obj1 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "self",(char *) "sz", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 {
3655 arg2 = &temp2;
3656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3657 }
3658 {
3659 PyThreadState* __tstate = wxPyBeginAllowThreads();
3660 (arg1)->DecTo((wxSize const &)*arg2);
3661
3662 wxPyEndAllowThreads(__tstate);
3663 if (PyErr_Occurred()) SWIG_fail;
3664 }
3665 Py_INCREF(Py_None); resultobj = Py_None;
3666 return resultobj;
3667 fail:
3668 return NULL;
3669 }
3670
3671
3672 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 int arg2 ;
3676 int arg3 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 PyObject * obj2 = 0 ;
3680 char *kwnames[] = {
3681 (char *) "self",(char *) "w",(char *) "h", NULL
3682 };
3683
3684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3686 if (SWIG_arg_fail(1)) SWIG_fail;
3687 {
3688 arg2 = (int)(SWIG_As_int(obj1));
3689 if (SWIG_arg_fail(2)) SWIG_fail;
3690 }
3691 {
3692 arg3 = (int)(SWIG_As_int(obj2));
3693 if (SWIG_arg_fail(3)) SWIG_fail;
3694 }
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 (arg1)->Set(arg2,arg3);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 Py_INCREF(Py_None); resultobj = Py_None;
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 wxSize *arg1 = (wxSize *) 0 ;
3712 int arg2 ;
3713 PyObject * obj0 = 0 ;
3714 PyObject * obj1 = 0 ;
3715 char *kwnames[] = {
3716 (char *) "self",(char *) "w", NULL
3717 };
3718
3719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3721 if (SWIG_arg_fail(1)) SWIG_fail;
3722 {
3723 arg2 = (int)(SWIG_As_int(obj1));
3724 if (SWIG_arg_fail(2)) SWIG_fail;
3725 }
3726 {
3727 PyThreadState* __tstate = wxPyBeginAllowThreads();
3728 (arg1)->SetWidth(arg2);
3729
3730 wxPyEndAllowThreads(__tstate);
3731 if (PyErr_Occurred()) SWIG_fail;
3732 }
3733 Py_INCREF(Py_None); resultobj = Py_None;
3734 return resultobj;
3735 fail:
3736 return NULL;
3737 }
3738
3739
3740 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3741 PyObject *resultobj;
3742 wxSize *arg1 = (wxSize *) 0 ;
3743 int arg2 ;
3744 PyObject * obj0 = 0 ;
3745 PyObject * obj1 = 0 ;
3746 char *kwnames[] = {
3747 (char *) "self",(char *) "h", NULL
3748 };
3749
3750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3752 if (SWIG_arg_fail(1)) SWIG_fail;
3753 {
3754 arg2 = (int)(SWIG_As_int(obj1));
3755 if (SWIG_arg_fail(2)) SWIG_fail;
3756 }
3757 {
3758 PyThreadState* __tstate = wxPyBeginAllowThreads();
3759 (arg1)->SetHeight(arg2);
3760
3761 wxPyEndAllowThreads(__tstate);
3762 if (PyErr_Occurred()) SWIG_fail;
3763 }
3764 Py_INCREF(Py_None); resultobj = Py_None;
3765 return resultobj;
3766 fail:
3767 return NULL;
3768 }
3769
3770
3771 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3772 PyObject *resultobj;
3773 wxSize *arg1 = (wxSize *) 0 ;
3774 int result;
3775 PyObject * obj0 = 0 ;
3776 char *kwnames[] = {
3777 (char *) "self", NULL
3778 };
3779
3780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3782 if (SWIG_arg_fail(1)) SWIG_fail;
3783 {
3784 PyThreadState* __tstate = wxPyBeginAllowThreads();
3785 result = (int)((wxSize const *)arg1)->GetWidth();
3786
3787 wxPyEndAllowThreads(__tstate);
3788 if (PyErr_Occurred()) SWIG_fail;
3789 }
3790 {
3791 resultobj = SWIG_From_int((int)(result));
3792 }
3793 return resultobj;
3794 fail:
3795 return NULL;
3796 }
3797
3798
3799 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3800 PyObject *resultobj;
3801 wxSize *arg1 = (wxSize *) 0 ;
3802 int result;
3803 PyObject * obj0 = 0 ;
3804 char *kwnames[] = {
3805 (char *) "self", NULL
3806 };
3807
3808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3810 if (SWIG_arg_fail(1)) SWIG_fail;
3811 {
3812 PyThreadState* __tstate = wxPyBeginAllowThreads();
3813 result = (int)((wxSize const *)arg1)->GetHeight();
3814
3815 wxPyEndAllowThreads(__tstate);
3816 if (PyErr_Occurred()) SWIG_fail;
3817 }
3818 {
3819 resultobj = SWIG_From_int((int)(result));
3820 }
3821 return resultobj;
3822 fail:
3823 return NULL;
3824 }
3825
3826
3827 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3828 PyObject *resultobj;
3829 wxSize *arg1 = (wxSize *) 0 ;
3830 bool result;
3831 PyObject * obj0 = 0 ;
3832 char *kwnames[] = {
3833 (char *) "self", NULL
3834 };
3835
3836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3838 if (SWIG_arg_fail(1)) SWIG_fail;
3839 {
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3842
3843 wxPyEndAllowThreads(__tstate);
3844 if (PyErr_Occurred()) SWIG_fail;
3845 }
3846 {
3847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3848 }
3849 return resultobj;
3850 fail:
3851 return NULL;
3852 }
3853
3854
3855 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3856 PyObject *resultobj;
3857 wxSize *arg1 = (wxSize *) 0 ;
3858 wxSize *arg2 = 0 ;
3859 wxSize temp2 ;
3860 PyObject * obj0 = 0 ;
3861 PyObject * obj1 = 0 ;
3862 char *kwnames[] = {
3863 (char *) "self",(char *) "size", NULL
3864 };
3865
3866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3868 if (SWIG_arg_fail(1)) SWIG_fail;
3869 {
3870 arg2 = &temp2;
3871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3872 }
3873 {
3874 PyThreadState* __tstate = wxPyBeginAllowThreads();
3875 (arg1)->SetDefaults((wxSize const &)*arg2);
3876
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 Py_INCREF(Py_None); resultobj = Py_None;
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxSize *arg1 = (wxSize *) 0 ;
3890 PyObject *result;
3891 PyObject * obj0 = 0 ;
3892 char *kwnames[] = {
3893 (char *) "self", NULL
3894 };
3895
3896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3898 if (SWIG_arg_fail(1)) SWIG_fail;
3899 {
3900 PyThreadState* __tstate = wxPyBeginAllowThreads();
3901 result = (PyObject *)wxSize_Get(arg1);
3902
3903 wxPyEndAllowThreads(__tstate);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 resultobj = result;
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3914 PyObject *obj;
3915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3916 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3917 Py_INCREF(obj);
3918 return Py_BuildValue((char *)"");
3919 }
3920 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3921 PyObject *resultobj;
3922 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3923 double arg2 ;
3924 PyObject * obj0 = 0 ;
3925 PyObject * obj1 = 0 ;
3926 char *kwnames[] = {
3927 (char *) "self",(char *) "x", NULL
3928 };
3929
3930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3932 if (SWIG_arg_fail(1)) SWIG_fail;
3933 {
3934 arg2 = (double)(SWIG_As_double(obj1));
3935 if (SWIG_arg_fail(2)) SWIG_fail;
3936 }
3937 if (arg1) (arg1)->x = arg2;
3938
3939 Py_INCREF(Py_None); resultobj = Py_None;
3940 return resultobj;
3941 fail:
3942 return NULL;
3943 }
3944
3945
3946 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3947 PyObject *resultobj;
3948 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3949 double result;
3950 PyObject * obj0 = 0 ;
3951 char *kwnames[] = {
3952 (char *) "self", NULL
3953 };
3954
3955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3957 if (SWIG_arg_fail(1)) SWIG_fail;
3958 result = (double) ((arg1)->x);
3959
3960 {
3961 resultobj = SWIG_From_double((double)(result));
3962 }
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3972 double arg2 ;
3973 PyObject * obj0 = 0 ;
3974 PyObject * obj1 = 0 ;
3975 char *kwnames[] = {
3976 (char *) "self",(char *) "y", NULL
3977 };
3978
3979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3981 if (SWIG_arg_fail(1)) SWIG_fail;
3982 {
3983 arg2 = (double)(SWIG_As_double(obj1));
3984 if (SWIG_arg_fail(2)) SWIG_fail;
3985 }
3986 if (arg1) (arg1)->y = arg2;
3987
3988 Py_INCREF(Py_None); resultobj = Py_None;
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3998 double result;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 result = (double) ((arg1)->y);
4008
4009 {
4010 resultobj = SWIG_From_double((double)(result));
4011 }
4012 return resultobj;
4013 fail:
4014 return NULL;
4015 }
4016
4017
4018 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4019 PyObject *resultobj;
4020 double arg1 = (double) 0.0 ;
4021 double arg2 = (double) 0.0 ;
4022 wxRealPoint *result;
4023 PyObject * obj0 = 0 ;
4024 PyObject * obj1 = 0 ;
4025 char *kwnames[] = {
4026 (char *) "x",(char *) "y", NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4030 if (obj0) {
4031 {
4032 arg1 = (double)(SWIG_As_double(obj0));
4033 if (SWIG_arg_fail(1)) SWIG_fail;
4034 }
4035 }
4036 if (obj1) {
4037 {
4038 arg2 = (double)(SWIG_As_double(obj1));
4039 if (SWIG_arg_fail(2)) SWIG_fail;
4040 }
4041 }
4042 {
4043 PyThreadState* __tstate = wxPyBeginAllowThreads();
4044 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4045
4046 wxPyEndAllowThreads(__tstate);
4047 if (PyErr_Occurred()) SWIG_fail;
4048 }
4049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4050 return resultobj;
4051 fail:
4052 return NULL;
4053 }
4054
4055
4056 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4057 PyObject *resultobj;
4058 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4059 PyObject * obj0 = 0 ;
4060 char *kwnames[] = {
4061 (char *) "self", NULL
4062 };
4063
4064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4066 if (SWIG_arg_fail(1)) SWIG_fail;
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 delete arg1;
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 Py_INCREF(Py_None); resultobj = Py_None;
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4084 wxRealPoint *arg2 = 0 ;
4085 bool result;
4086 wxRealPoint temp2 ;
4087 PyObject * obj0 = 0 ;
4088 PyObject * obj1 = 0 ;
4089 char *kwnames[] = {
4090 (char *) "self",(char *) "pt", NULL
4091 };
4092
4093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4095 if (SWIG_arg_fail(1)) SWIG_fail;
4096 {
4097 arg2 = &temp2;
4098 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4099 }
4100 {
4101 PyThreadState* __tstate = wxPyBeginAllowThreads();
4102 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4103
4104 wxPyEndAllowThreads(__tstate);
4105 if (PyErr_Occurred()) SWIG_fail;
4106 }
4107 {
4108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4109 }
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj;
4118 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4119 wxRealPoint *arg2 = 0 ;
4120 bool result;
4121 wxRealPoint temp2 ;
4122 PyObject * obj0 = 0 ;
4123 PyObject * obj1 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "self",(char *) "pt", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4130 if (SWIG_arg_fail(1)) SWIG_fail;
4131 {
4132 arg2 = &temp2;
4133 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4134 }
4135 {
4136 PyThreadState* __tstate = wxPyBeginAllowThreads();
4137 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4138
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 {
4143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4144 }
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj;
4153 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4154 wxRealPoint *arg2 = 0 ;
4155 wxRealPoint result;
4156 wxRealPoint temp2 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "self",(char *) "pt", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4165 if (SWIG_arg_fail(1)) SWIG_fail;
4166 {
4167 arg2 = &temp2;
4168 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4169 }
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 {
4178 wxRealPoint * resultptr;
4179 resultptr = new wxRealPoint((wxRealPoint &)(result));
4180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4181 }
4182 return resultobj;
4183 fail:
4184 return NULL;
4185 }
4186
4187
4188 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4189 PyObject *resultobj;
4190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4191 wxRealPoint *arg2 = 0 ;
4192 wxRealPoint result;
4193 wxRealPoint temp2 ;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 char *kwnames[] = {
4197 (char *) "self",(char *) "pt", NULL
4198 };
4199
4200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4202 if (SWIG_arg_fail(1)) SWIG_fail;
4203 {
4204 arg2 = &temp2;
4205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4206 }
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 wxRealPoint * resultptr;
4216 resultptr = new wxRealPoint((wxRealPoint &)(result));
4217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4228 double arg2 ;
4229 double arg3 ;
4230 PyObject * obj0 = 0 ;
4231 PyObject * obj1 = 0 ;
4232 PyObject * obj2 = 0 ;
4233 char *kwnames[] = {
4234 (char *) "self",(char *) "x",(char *) "y", NULL
4235 };
4236
4237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4239 if (SWIG_arg_fail(1)) SWIG_fail;
4240 {
4241 arg2 = (double)(SWIG_As_double(obj1));
4242 if (SWIG_arg_fail(2)) SWIG_fail;
4243 }
4244 {
4245 arg3 = (double)(SWIG_As_double(obj2));
4246 if (SWIG_arg_fail(3)) SWIG_fail;
4247 }
4248 {
4249 PyThreadState* __tstate = wxPyBeginAllowThreads();
4250 wxRealPoint_Set(arg1,arg2,arg3);
4251
4252 wxPyEndAllowThreads(__tstate);
4253 if (PyErr_Occurred()) SWIG_fail;
4254 }
4255 Py_INCREF(Py_None); resultobj = Py_None;
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4265 PyObject *result;
4266 PyObject * obj0 = 0 ;
4267 char *kwnames[] = {
4268 (char *) "self", NULL
4269 };
4270
4271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4273 if (SWIG_arg_fail(1)) SWIG_fail;
4274 {
4275 PyThreadState* __tstate = wxPyBeginAllowThreads();
4276 result = (PyObject *)wxRealPoint_Get(arg1);
4277
4278 wxPyEndAllowThreads(__tstate);
4279 if (PyErr_Occurred()) SWIG_fail;
4280 }
4281 resultobj = result;
4282 return resultobj;
4283 fail:
4284 return NULL;
4285 }
4286
4287
4288 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4289 PyObject *obj;
4290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4291 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4292 Py_INCREF(obj);
4293 return Py_BuildValue((char *)"");
4294 }
4295 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4296 PyObject *resultobj;
4297 wxPoint *arg1 = (wxPoint *) 0 ;
4298 int arg2 ;
4299 PyObject * obj0 = 0 ;
4300 PyObject * obj1 = 0 ;
4301 char *kwnames[] = {
4302 (char *) "self",(char *) "x", NULL
4303 };
4304
4305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4307 if (SWIG_arg_fail(1)) SWIG_fail;
4308 {
4309 arg2 = (int)(SWIG_As_int(obj1));
4310 if (SWIG_arg_fail(2)) SWIG_fail;
4311 }
4312 if (arg1) (arg1)->x = arg2;
4313
4314 Py_INCREF(Py_None); resultobj = Py_None;
4315 return resultobj;
4316 fail:
4317 return NULL;
4318 }
4319
4320
4321 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4322 PyObject *resultobj;
4323 wxPoint *arg1 = (wxPoint *) 0 ;
4324 int result;
4325 PyObject * obj0 = 0 ;
4326 char *kwnames[] = {
4327 (char *) "self", NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4332 if (SWIG_arg_fail(1)) SWIG_fail;
4333 result = (int) ((arg1)->x);
4334
4335 {
4336 resultobj = SWIG_From_int((int)(result));
4337 }
4338 return resultobj;
4339 fail:
4340 return NULL;
4341 }
4342
4343
4344 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4345 PyObject *resultobj;
4346 wxPoint *arg1 = (wxPoint *) 0 ;
4347 int arg2 ;
4348 PyObject * obj0 = 0 ;
4349 PyObject * obj1 = 0 ;
4350 char *kwnames[] = {
4351 (char *) "self",(char *) "y", NULL
4352 };
4353
4354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4356 if (SWIG_arg_fail(1)) SWIG_fail;
4357 {
4358 arg2 = (int)(SWIG_As_int(obj1));
4359 if (SWIG_arg_fail(2)) SWIG_fail;
4360 }
4361 if (arg1) (arg1)->y = arg2;
4362
4363 Py_INCREF(Py_None); resultobj = Py_None;
4364 return resultobj;
4365 fail:
4366 return NULL;
4367 }
4368
4369
4370 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj;
4372 wxPoint *arg1 = (wxPoint *) 0 ;
4373 int result;
4374 PyObject * obj0 = 0 ;
4375 char *kwnames[] = {
4376 (char *) "self", NULL
4377 };
4378
4379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4381 if (SWIG_arg_fail(1)) SWIG_fail;
4382 result = (int) ((arg1)->y);
4383
4384 {
4385 resultobj = SWIG_From_int((int)(result));
4386 }
4387 return resultobj;
4388 fail:
4389 return NULL;
4390 }
4391
4392
4393 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4394 PyObject *resultobj;
4395 int arg1 = (int) 0 ;
4396 int arg2 = (int) 0 ;
4397 wxPoint *result;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "x",(char *) "y", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4405 if (obj0) {
4406 {
4407 arg1 = (int)(SWIG_As_int(obj0));
4408 if (SWIG_arg_fail(1)) SWIG_fail;
4409 }
4410 }
4411 if (obj1) {
4412 {
4413 arg2 = (int)(SWIG_As_int(obj1));
4414 if (SWIG_arg_fail(2)) SWIG_fail;
4415 }
4416 }
4417 {
4418 PyThreadState* __tstate = wxPyBeginAllowThreads();
4419 result = (wxPoint *)new wxPoint(arg1,arg2);
4420
4421 wxPyEndAllowThreads(__tstate);
4422 if (PyErr_Occurred()) SWIG_fail;
4423 }
4424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4432 PyObject *resultobj;
4433 wxPoint *arg1 = (wxPoint *) 0 ;
4434 PyObject * obj0 = 0 ;
4435 char *kwnames[] = {
4436 (char *) "self", NULL
4437 };
4438
4439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4441 if (SWIG_arg_fail(1)) SWIG_fail;
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 delete arg1;
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 Py_INCREF(Py_None); resultobj = Py_None;
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj;
4458 wxPoint *arg1 = (wxPoint *) 0 ;
4459 wxPoint *arg2 = 0 ;
4460 bool result;
4461 wxPoint temp2 ;
4462 PyObject * obj0 = 0 ;
4463 PyObject * obj1 = 0 ;
4464 char *kwnames[] = {
4465 (char *) "self",(char *) "pt", NULL
4466 };
4467
4468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4470 if (SWIG_arg_fail(1)) SWIG_fail;
4471 {
4472 arg2 = &temp2;
4473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4474 }
4475 {
4476 PyThreadState* __tstate = wxPyBeginAllowThreads();
4477 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4478
4479 wxPyEndAllowThreads(__tstate);
4480 if (PyErr_Occurred()) SWIG_fail;
4481 }
4482 {
4483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4492 PyObject *resultobj;
4493 wxPoint *arg1 = (wxPoint *) 0 ;
4494 wxPoint *arg2 = 0 ;
4495 bool result;
4496 wxPoint temp2 ;
4497 PyObject * obj0 = 0 ;
4498 PyObject * obj1 = 0 ;
4499 char *kwnames[] = {
4500 (char *) "self",(char *) "pt", NULL
4501 };
4502
4503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4505 if (SWIG_arg_fail(1)) SWIG_fail;
4506 {
4507 arg2 = &temp2;
4508 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4509 }
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4513
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj;
4528 wxPoint *arg1 = (wxPoint *) 0 ;
4529 wxPoint *arg2 = 0 ;
4530 wxPoint result;
4531 wxPoint temp2 ;
4532 PyObject * obj0 = 0 ;
4533 PyObject * obj1 = 0 ;
4534 char *kwnames[] = {
4535 (char *) "self",(char *) "pt", NULL
4536 };
4537
4538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4540 if (SWIG_arg_fail(1)) SWIG_fail;
4541 {
4542 arg2 = &temp2;
4543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4544 }
4545 {
4546 PyThreadState* __tstate = wxPyBeginAllowThreads();
4547 result = (arg1)->operator +((wxPoint const &)*arg2);
4548
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 wxPoint * resultptr;
4554 resultptr = new wxPoint((wxPoint &)(result));
4555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4556 }
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj;
4565 wxPoint *arg1 = (wxPoint *) 0 ;
4566 wxPoint *arg2 = 0 ;
4567 wxPoint result;
4568 wxPoint temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char *kwnames[] = {
4572 (char *) "self",(char *) "pt", NULL
4573 };
4574
4575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4577 if (SWIG_arg_fail(1)) SWIG_fail;
4578 {
4579 arg2 = &temp2;
4580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (arg1)->operator -((wxPoint const &)*arg2);
4585
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 {
4590 wxPoint * resultptr;
4591 resultptr = new wxPoint((wxPoint &)(result));
4592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4593 }
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj;
4602 wxPoint *arg1 = (wxPoint *) 0 ;
4603 wxPoint *arg2 = 0 ;
4604 wxPoint *result;
4605 wxPoint temp2 ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 char *kwnames[] = {
4609 (char *) "self",(char *) "pt", NULL
4610 };
4611
4612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4614 if (SWIG_arg_fail(1)) SWIG_fail;
4615 {
4616 arg2 = &temp2;
4617 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 {
4622 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4623 result = (wxPoint *) &_result_ref;
4624 }
4625
4626 wxPyEndAllowThreads(__tstate);
4627 if (PyErr_Occurred()) SWIG_fail;
4628 }
4629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4637 PyObject *resultobj;
4638 wxPoint *arg1 = (wxPoint *) 0 ;
4639 wxPoint *arg2 = 0 ;
4640 wxPoint *result;
4641 wxPoint temp2 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 char *kwnames[] = {
4645 (char *) "self",(char *) "pt", NULL
4646 };
4647
4648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4650 if (SWIG_arg_fail(1)) SWIG_fail;
4651 {
4652 arg2 = &temp2;
4653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4654 }
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 {
4658 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4659 result = (wxPoint *) &_result_ref;
4660 }
4661
4662 wxPyEndAllowThreads(__tstate);
4663 if (PyErr_Occurred()) SWIG_fail;
4664 }
4665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj;
4674 wxPoint *arg1 = (wxPoint *) 0 ;
4675 long arg2 ;
4676 long arg3 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 PyObject * obj2 = 0 ;
4680 char *kwnames[] = {
4681 (char *) "self",(char *) "x",(char *) "y", NULL
4682 };
4683
4684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4686 if (SWIG_arg_fail(1)) SWIG_fail;
4687 {
4688 arg2 = (long)(SWIG_As_long(obj1));
4689 if (SWIG_arg_fail(2)) SWIG_fail;
4690 }
4691 {
4692 arg3 = (long)(SWIG_As_long(obj2));
4693 if (SWIG_arg_fail(3)) SWIG_fail;
4694 }
4695 {
4696 PyThreadState* __tstate = wxPyBeginAllowThreads();
4697 wxPoint_Set(arg1,arg2,arg3);
4698
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 Py_INCREF(Py_None); resultobj = Py_None;
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj;
4711 wxPoint *arg1 = (wxPoint *) 0 ;
4712 PyObject *result;
4713 PyObject * obj0 = 0 ;
4714 char *kwnames[] = {
4715 (char *) "self", NULL
4716 };
4717
4718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4720 if (SWIG_arg_fail(1)) SWIG_fail;
4721 {
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = (PyObject *)wxPoint_Get(arg1);
4724
4725 wxPyEndAllowThreads(__tstate);
4726 if (PyErr_Occurred()) SWIG_fail;
4727 }
4728 resultobj = result;
4729 return resultobj;
4730 fail:
4731 return NULL;
4732 }
4733
4734
4735 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4736 PyObject *obj;
4737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4738 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4739 Py_INCREF(obj);
4740 return Py_BuildValue((char *)"");
4741 }
4742 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj;
4744 int arg1 = (int) 0 ;
4745 int arg2 = (int) 0 ;
4746 int arg3 = (int) 0 ;
4747 int arg4 = (int) 0 ;
4748 wxRect *result;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 PyObject * obj2 = 0 ;
4752 PyObject * obj3 = 0 ;
4753 char *kwnames[] = {
4754 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4755 };
4756
4757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4758 if (obj0) {
4759 {
4760 arg1 = (int)(SWIG_As_int(obj0));
4761 if (SWIG_arg_fail(1)) SWIG_fail;
4762 }
4763 }
4764 if (obj1) {
4765 {
4766 arg2 = (int)(SWIG_As_int(obj1));
4767 if (SWIG_arg_fail(2)) SWIG_fail;
4768 }
4769 }
4770 if (obj2) {
4771 {
4772 arg3 = (int)(SWIG_As_int(obj2));
4773 if (SWIG_arg_fail(3)) SWIG_fail;
4774 }
4775 }
4776 if (obj3) {
4777 {
4778 arg4 = (int)(SWIG_As_int(obj3));
4779 if (SWIG_arg_fail(4)) SWIG_fail;
4780 }
4781 }
4782 {
4783 PyThreadState* __tstate = wxPyBeginAllowThreads();
4784 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4785
4786 wxPyEndAllowThreads(__tstate);
4787 if (PyErr_Occurred()) SWIG_fail;
4788 }
4789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4790 return resultobj;
4791 fail:
4792 return NULL;
4793 }
4794
4795
4796 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4797 PyObject *resultobj;
4798 wxPoint *arg1 = 0 ;
4799 wxPoint *arg2 = 0 ;
4800 wxRect *result;
4801 wxPoint temp1 ;
4802 wxPoint temp2 ;
4803 PyObject * obj0 = 0 ;
4804 PyObject * obj1 = 0 ;
4805 char *kwnames[] = {
4806 (char *) "topLeft",(char *) "bottomRight", NULL
4807 };
4808
4809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4810 {
4811 arg1 = &temp1;
4812 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4813 }
4814 {
4815 arg2 = &temp2;
4816 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4817 }
4818 {
4819 PyThreadState* __tstate = wxPyBeginAllowThreads();
4820 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4821
4822 wxPyEndAllowThreads(__tstate);
4823 if (PyErr_Occurred()) SWIG_fail;
4824 }
4825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4826 return resultobj;
4827 fail:
4828 return NULL;
4829 }
4830
4831
4832 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4833 PyObject *resultobj;
4834 wxPoint *arg1 = 0 ;
4835 wxSize *arg2 = 0 ;
4836 wxRect *result;
4837 wxPoint temp1 ;
4838 wxSize temp2 ;
4839 PyObject * obj0 = 0 ;
4840 PyObject * obj1 = 0 ;
4841 char *kwnames[] = {
4842 (char *) "pos",(char *) "size", NULL
4843 };
4844
4845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4846 {
4847 arg1 = &temp1;
4848 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4849 }
4850 {
4851 arg2 = &temp2;
4852 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4853 }
4854 {
4855 PyThreadState* __tstate = wxPyBeginAllowThreads();
4856 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4857
4858 wxPyEndAllowThreads(__tstate);
4859 if (PyErr_Occurred()) SWIG_fail;
4860 }
4861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4862 return resultobj;
4863 fail:
4864 return NULL;
4865 }
4866
4867
4868 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4869 PyObject *resultobj;
4870 wxSize *arg1 = 0 ;
4871 wxRect *result;
4872 wxSize temp1 ;
4873 PyObject * obj0 = 0 ;
4874 char *kwnames[] = {
4875 (char *) "size", NULL
4876 };
4877
4878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4879 {
4880 arg1 = &temp1;
4881 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4882 }
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4886
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj;
4899 wxRect *arg1 = (wxRect *) 0 ;
4900 PyObject * obj0 = 0 ;
4901 char *kwnames[] = {
4902 (char *) "self", NULL
4903 };
4904
4905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4907 if (SWIG_arg_fail(1)) SWIG_fail;
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 delete arg1;
4911
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 Py_INCREF(Py_None); resultobj = Py_None;
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxRect *arg1 = (wxRect *) 0 ;
4925 int result;
4926 PyObject * obj0 = 0 ;
4927 char *kwnames[] = {
4928 (char *) "self", NULL
4929 };
4930
4931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4933 if (SWIG_arg_fail(1)) SWIG_fail;
4934 {
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 result = (int)((wxRect const *)arg1)->GetX();
4937
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 {
4942 resultobj = SWIG_From_int((int)(result));
4943 }
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj;
4952 wxRect *arg1 = (wxRect *) 0 ;
4953 int arg2 ;
4954 PyObject * obj0 = 0 ;
4955 PyObject * obj1 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "self",(char *) "x", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4962 if (SWIG_arg_fail(1)) SWIG_fail;
4963 {
4964 arg2 = (int)(SWIG_As_int(obj1));
4965 if (SWIG_arg_fail(2)) SWIG_fail;
4966 }
4967 {
4968 PyThreadState* __tstate = wxPyBeginAllowThreads();
4969 (arg1)->SetX(arg2);
4970
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 Py_INCREF(Py_None); resultobj = Py_None;
4975 return resultobj;
4976 fail:
4977 return NULL;
4978 }
4979
4980
4981 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4982 PyObject *resultobj;
4983 wxRect *arg1 = (wxRect *) 0 ;
4984 int result;
4985 PyObject * obj0 = 0 ;
4986 char *kwnames[] = {
4987 (char *) "self", NULL
4988 };
4989
4990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4992 if (SWIG_arg_fail(1)) SWIG_fail;
4993 {
4994 PyThreadState* __tstate = wxPyBeginAllowThreads();
4995 result = (int)(arg1)->GetY();
4996
4997 wxPyEndAllowThreads(__tstate);
4998 if (PyErr_Occurred()) SWIG_fail;
4999 }
5000 {
5001 resultobj = SWIG_From_int((int)(result));
5002 }
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5010 PyObject *resultobj;
5011 wxRect *arg1 = (wxRect *) 0 ;
5012 int arg2 ;
5013 PyObject * obj0 = 0 ;
5014 PyObject * obj1 = 0 ;
5015 char *kwnames[] = {
5016 (char *) "self",(char *) "y", NULL
5017 };
5018
5019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5021 if (SWIG_arg_fail(1)) SWIG_fail;
5022 {
5023 arg2 = (int)(SWIG_As_int(obj1));
5024 if (SWIG_arg_fail(2)) SWIG_fail;
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetY(arg2);
5029
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 Py_INCREF(Py_None); resultobj = Py_None;
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5041 PyObject *resultobj;
5042 wxRect *arg1 = (wxRect *) 0 ;
5043 int result;
5044 PyObject * obj0 = 0 ;
5045 char *kwnames[] = {
5046 (char *) "self", NULL
5047 };
5048
5049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5051 if (SWIG_arg_fail(1)) SWIG_fail;
5052 {
5053 PyThreadState* __tstate = wxPyBeginAllowThreads();
5054 result = (int)((wxRect const *)arg1)->GetWidth();
5055
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 {
5060 resultobj = SWIG_From_int((int)(result));
5061 }
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5069 PyObject *resultobj;
5070 wxRect *arg1 = (wxRect *) 0 ;
5071 int arg2 ;
5072 PyObject * obj0 = 0 ;
5073 PyObject * obj1 = 0 ;
5074 char *kwnames[] = {
5075 (char *) "self",(char *) "w", NULL
5076 };
5077
5078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5080 if (SWIG_arg_fail(1)) SWIG_fail;
5081 {
5082 arg2 = (int)(SWIG_As_int(obj1));
5083 if (SWIG_arg_fail(2)) SWIG_fail;
5084 }
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 (arg1)->SetWidth(arg2);
5088
5089 wxPyEndAllowThreads(__tstate);
5090 if (PyErr_Occurred()) SWIG_fail;
5091 }
5092 Py_INCREF(Py_None); resultobj = Py_None;
5093 return resultobj;
5094 fail:
5095 return NULL;
5096 }
5097
5098
5099 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5100 PyObject *resultobj;
5101 wxRect *arg1 = (wxRect *) 0 ;
5102 int result;
5103 PyObject * obj0 = 0 ;
5104 char *kwnames[] = {
5105 (char *) "self", NULL
5106 };
5107
5108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5110 if (SWIG_arg_fail(1)) SWIG_fail;
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (int)((wxRect const *)arg1)->GetHeight();
5114
5115 wxPyEndAllowThreads(__tstate);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 {
5119 resultobj = SWIG_From_int((int)(result));
5120 }
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj;
5129 wxRect *arg1 = (wxRect *) 0 ;
5130 int arg2 ;
5131 PyObject * obj0 = 0 ;
5132 PyObject * obj1 = 0 ;
5133 char *kwnames[] = {
5134 (char *) "self",(char *) "h", NULL
5135 };
5136
5137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5139 if (SWIG_arg_fail(1)) SWIG_fail;
5140 {
5141 arg2 = (int)(SWIG_As_int(obj1));
5142 if (SWIG_arg_fail(2)) SWIG_fail;
5143 }
5144 {
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 (arg1)->SetHeight(arg2);
5147
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 Py_INCREF(Py_None); resultobj = Py_None;
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5159 PyObject *resultobj;
5160 wxRect *arg1 = (wxRect *) 0 ;
5161 wxPoint result;
5162 PyObject * obj0 = 0 ;
5163 char *kwnames[] = {
5164 (char *) "self", NULL
5165 };
5166
5167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5169 if (SWIG_arg_fail(1)) SWIG_fail;
5170 {
5171 PyThreadState* __tstate = wxPyBeginAllowThreads();
5172 result = ((wxRect const *)arg1)->GetPosition();
5173
5174 wxPyEndAllowThreads(__tstate);
5175 if (PyErr_Occurred()) SWIG_fail;
5176 }
5177 {
5178 wxPoint * resultptr;
5179 resultptr = new wxPoint((wxPoint &)(result));
5180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5181 }
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5189 PyObject *resultobj;
5190 wxRect *arg1 = (wxRect *) 0 ;
5191 wxPoint *arg2 = 0 ;
5192 wxPoint temp2 ;
5193 PyObject * obj0 = 0 ;
5194 PyObject * obj1 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self",(char *) "p", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5201 if (SWIG_arg_fail(1)) SWIG_fail;
5202 {
5203 arg2 = &temp2;
5204 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5205 }
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 (arg1)->SetPosition((wxPoint const &)*arg2);
5209
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 Py_INCREF(Py_None); resultobj = Py_None;
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 wxSize result;
5224 PyObject * obj0 = 0 ;
5225 char *kwnames[] = {
5226 (char *) "self", NULL
5227 };
5228
5229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5231 if (SWIG_arg_fail(1)) SWIG_fail;
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 result = ((wxRect const *)arg1)->GetSize();
5235
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 {
5240 wxSize * resultptr;
5241 resultptr = new wxSize((wxSize &)(result));
5242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5243 }
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj;
5252 wxRect *arg1 = (wxRect *) 0 ;
5253 wxSize *arg2 = 0 ;
5254 wxSize temp2 ;
5255 PyObject * obj0 = 0 ;
5256 PyObject * obj1 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self",(char *) "s", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 {
5265 arg2 = &temp2;
5266 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5267 }
5268 {
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 (arg1)->SetSize((wxSize const &)*arg2);
5271
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 Py_INCREF(Py_None); resultobj = Py_None;
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxRect *arg1 = (wxRect *) 0 ;
5285 bool result;
5286 PyObject * obj0 = 0 ;
5287 char *kwnames[] = {
5288 (char *) "self", NULL
5289 };
5290
5291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5293 if (SWIG_arg_fail(1)) SWIG_fail;
5294 {
5295 PyThreadState* __tstate = wxPyBeginAllowThreads();
5296 result = (bool)((wxRect const *)arg1)->IsEmpty();
5297
5298 wxPyEndAllowThreads(__tstate);
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 {
5302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5303 }
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj;
5312 wxRect *arg1 = (wxRect *) 0 ;
5313 wxPoint result;
5314 PyObject * obj0 = 0 ;
5315 char *kwnames[] = {
5316 (char *) "self", NULL
5317 };
5318
5319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5321 if (SWIG_arg_fail(1)) SWIG_fail;
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = ((wxRect const *)arg1)->GetTopLeft();
5325
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 {
5330 wxPoint * resultptr;
5331 resultptr = new wxPoint((wxPoint &)(result));
5332 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5333 }
5334 return resultobj;
5335 fail:
5336 return NULL;
5337 }
5338
5339
5340 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5341 PyObject *resultobj;
5342 wxRect *arg1 = (wxRect *) 0 ;
5343 wxPoint *arg2 = 0 ;
5344 wxPoint temp2 ;
5345 PyObject * obj0 = 0 ;
5346 PyObject * obj1 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self",(char *) "p", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 arg2 = &temp2;
5356 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5357 }
5358 {
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5361
5362 wxPyEndAllowThreads(__tstate);
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 Py_INCREF(Py_None); resultobj = Py_None;
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint result;
5376 PyObject * obj0 = 0 ;
5377 char *kwnames[] = {
5378 (char *) "self", NULL
5379 };
5380
5381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5383 if (SWIG_arg_fail(1)) SWIG_fail;
5384 {
5385 PyThreadState* __tstate = wxPyBeginAllowThreads();
5386 result = ((wxRect const *)arg1)->GetBottomRight();
5387
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 {
5392 wxPoint * resultptr;
5393 resultptr = new wxPoint((wxPoint &)(result));
5394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5395 }
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj;
5404 wxRect *arg1 = (wxRect *) 0 ;
5405 wxPoint *arg2 = 0 ;
5406 wxPoint temp2 ;
5407 PyObject * obj0 = 0 ;
5408 PyObject * obj1 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self",(char *) "p", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(1)) SWIG_fail;
5416 {
5417 arg2 = &temp2;
5418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5419 }
5420 {
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5423
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 Py_INCREF(Py_None); resultobj = Py_None;
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj;
5436 wxRect *arg1 = (wxRect *) 0 ;
5437 int result;
5438 PyObject * obj0 = 0 ;
5439 char *kwnames[] = {
5440 (char *) "self", NULL
5441 };
5442
5443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5445 if (SWIG_arg_fail(1)) SWIG_fail;
5446 {
5447 PyThreadState* __tstate = wxPyBeginAllowThreads();
5448 result = (int)((wxRect const *)arg1)->GetLeft();
5449
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 {
5454 resultobj = SWIG_From_int((int)(result));
5455 }
5456 return resultobj;
5457 fail:
5458 return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj;
5464 wxRect *arg1 = (wxRect *) 0 ;
5465 int result;
5466 PyObject * obj0 = 0 ;
5467 char *kwnames[] = {
5468 (char *) "self", NULL
5469 };
5470
5471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5473 if (SWIG_arg_fail(1)) SWIG_fail;
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 result = (int)((wxRect const *)arg1)->GetTop();
5477
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 {
5482 resultobj = SWIG_From_int((int)(result));
5483 }
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5491 PyObject *resultobj;
5492 wxRect *arg1 = (wxRect *) 0 ;
5493 int result;
5494 PyObject * obj0 = 0 ;
5495 char *kwnames[] = {
5496 (char *) "self", NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5501 if (SWIG_arg_fail(1)) SWIG_fail;
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = (int)((wxRect const *)arg1)->GetBottom();
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 {
5510 resultobj = SWIG_From_int((int)(result));
5511 }
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj;
5520 wxRect *arg1 = (wxRect *) 0 ;
5521 int result;
5522 PyObject * obj0 = 0 ;
5523 char *kwnames[] = {
5524 (char *) "self", NULL
5525 };
5526
5527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5529 if (SWIG_arg_fail(1)) SWIG_fail;
5530 {
5531 PyThreadState* __tstate = wxPyBeginAllowThreads();
5532 result = (int)((wxRect const *)arg1)->GetRight();
5533
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 {
5538 resultobj = SWIG_From_int((int)(result));
5539 }
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
5546 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5547 PyObject *resultobj;
5548 wxRect *arg1 = (wxRect *) 0 ;
5549 int arg2 ;
5550 PyObject * obj0 = 0 ;
5551 PyObject * obj1 = 0 ;
5552 char *kwnames[] = {
5553 (char *) "self",(char *) "left", NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5558 if (SWIG_arg_fail(1)) SWIG_fail;
5559 {
5560 arg2 = (int)(SWIG_As_int(obj1));
5561 if (SWIG_arg_fail(2)) SWIG_fail;
5562 }
5563 {
5564 PyThreadState* __tstate = wxPyBeginAllowThreads();
5565 (arg1)->SetLeft(arg2);
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 Py_INCREF(Py_None); resultobj = Py_None;
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj;
5579 wxRect *arg1 = (wxRect *) 0 ;
5580 int arg2 ;
5581 PyObject * obj0 = 0 ;
5582 PyObject * obj1 = 0 ;
5583 char *kwnames[] = {
5584 (char *) "self",(char *) "right", NULL
5585 };
5586
5587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5589 if (SWIG_arg_fail(1)) SWIG_fail;
5590 {
5591 arg2 = (int)(SWIG_As_int(obj1));
5592 if (SWIG_arg_fail(2)) SWIG_fail;
5593 }
5594 {
5595 PyThreadState* __tstate = wxPyBeginAllowThreads();
5596 (arg1)->SetRight(arg2);
5597
5598 wxPyEndAllowThreads(__tstate);
5599 if (PyErr_Occurred()) SWIG_fail;
5600 }
5601 Py_INCREF(Py_None); resultobj = Py_None;
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5609 PyObject *resultobj;
5610 wxRect *arg1 = (wxRect *) 0 ;
5611 int arg2 ;
5612 PyObject * obj0 = 0 ;
5613 PyObject * obj1 = 0 ;
5614 char *kwnames[] = {
5615 (char *) "self",(char *) "top", NULL
5616 };
5617
5618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5620 if (SWIG_arg_fail(1)) SWIG_fail;
5621 {
5622 arg2 = (int)(SWIG_As_int(obj1));
5623 if (SWIG_arg_fail(2)) SWIG_fail;
5624 }
5625 {
5626 PyThreadState* __tstate = wxPyBeginAllowThreads();
5627 (arg1)->SetTop(arg2);
5628
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 Py_INCREF(Py_None); resultobj = Py_None;
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj;
5641 wxRect *arg1 = (wxRect *) 0 ;
5642 int arg2 ;
5643 PyObject * obj0 = 0 ;
5644 PyObject * obj1 = 0 ;
5645 char *kwnames[] = {
5646 (char *) "self",(char *) "bottom", NULL
5647 };
5648
5649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5651 if (SWIG_arg_fail(1)) SWIG_fail;
5652 {
5653 arg2 = (int)(SWIG_As_int(obj1));
5654 if (SWIG_arg_fail(2)) SWIG_fail;
5655 }
5656 {
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 (arg1)->SetBottom(arg2);
5659
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 Py_INCREF(Py_None); resultobj = Py_None;
5664 return resultobj;
5665 fail:
5666 return NULL;
5667 }
5668
5669
5670 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5671 PyObject *resultobj;
5672 wxRect *arg1 = (wxRect *) 0 ;
5673 int arg2 ;
5674 int arg3 ;
5675 wxRect *result;
5676 PyObject * obj0 = 0 ;
5677 PyObject * obj1 = 0 ;
5678 PyObject * obj2 = 0 ;
5679 char *kwnames[] = {
5680 (char *) "self",(char *) "dx",(char *) "dy", NULL
5681 };
5682
5683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5685 if (SWIG_arg_fail(1)) SWIG_fail;
5686 {
5687 arg2 = (int)(SWIG_As_int(obj1));
5688 if (SWIG_arg_fail(2)) SWIG_fail;
5689 }
5690 {
5691 arg3 = (int)(SWIG_As_int(obj2));
5692 if (SWIG_arg_fail(3)) SWIG_fail;
5693 }
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 {
5697 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5698 result = (wxRect *) &_result_ref;
5699 }
5700
5701 wxPyEndAllowThreads(__tstate);
5702 if (PyErr_Occurred()) SWIG_fail;
5703 }
5704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj;
5713 wxRect *arg1 = (wxRect *) 0 ;
5714 int arg2 ;
5715 int arg3 ;
5716 wxRect *result;
5717 PyObject * obj0 = 0 ;
5718 PyObject * obj1 = 0 ;
5719 PyObject * obj2 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "self",(char *) "dx",(char *) "dy", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5726 if (SWIG_arg_fail(1)) SWIG_fail;
5727 {
5728 arg2 = (int)(SWIG_As_int(obj1));
5729 if (SWIG_arg_fail(2)) SWIG_fail;
5730 }
5731 {
5732 arg3 = (int)(SWIG_As_int(obj2));
5733 if (SWIG_arg_fail(3)) SWIG_fail;
5734 }
5735 {
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 {
5738 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5739 result = (wxRect *) &_result_ref;
5740 }
5741
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj;
5754 wxRect *arg1 = (wxRect *) 0 ;
5755 int arg2 ;
5756 int arg3 ;
5757 PyObject * obj0 = 0 ;
5758 PyObject * obj1 = 0 ;
5759 PyObject * obj2 = 0 ;
5760 char *kwnames[] = {
5761 (char *) "self",(char *) "dx",(char *) "dy", NULL
5762 };
5763
5764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5766 if (SWIG_arg_fail(1)) SWIG_fail;
5767 {
5768 arg2 = (int)(SWIG_As_int(obj1));
5769 if (SWIG_arg_fail(2)) SWIG_fail;
5770 }
5771 {
5772 arg3 = (int)(SWIG_As_int(obj2));
5773 if (SWIG_arg_fail(3)) SWIG_fail;
5774 }
5775 {
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 (arg1)->Offset(arg2,arg3);
5778
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 Py_INCREF(Py_None); resultobj = Py_None;
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5790 PyObject *resultobj;
5791 wxRect *arg1 = (wxRect *) 0 ;
5792 wxPoint *arg2 = 0 ;
5793 wxPoint temp2 ;
5794 PyObject * obj0 = 0 ;
5795 PyObject * obj1 = 0 ;
5796 char *kwnames[] = {
5797 (char *) "self",(char *) "pt", NULL
5798 };
5799
5800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5802 if (SWIG_arg_fail(1)) SWIG_fail;
5803 {
5804 arg2 = &temp2;
5805 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 (arg1)->Offset((wxPoint const &)*arg2);
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 Py_INCREF(Py_None); resultobj = Py_None;
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 wxRect *arg2 = 0 ;
5825 wxRect result;
5826 wxRect temp2 ;
5827 PyObject * obj0 = 0 ;
5828 PyObject * obj1 = 0 ;
5829 char *kwnames[] = {
5830 (char *) "self",(char *) "rect", NULL
5831 };
5832
5833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5835 if (SWIG_arg_fail(1)) SWIG_fail;
5836 {
5837 arg2 = &temp2;
5838 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 result = (arg1)->Intersect((wxRect const &)*arg2);
5843
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 {
5848 wxRect * resultptr;
5849 resultptr = new wxRect((wxRect &)(result));
5850 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5851 }
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj;
5860 wxRect *arg1 = (wxRect *) 0 ;
5861 wxRect *arg2 = 0 ;
5862 wxRect result;
5863 wxRect temp2 ;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 char *kwnames[] = {
5867 (char *) "self",(char *) "rect", NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5872 if (SWIG_arg_fail(1)) SWIG_fail;
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 result = (arg1)->Union((wxRect const &)*arg2);
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 {
5885 wxRect * resultptr;
5886 resultptr = new wxRect((wxRect &)(result));
5887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5888 }
5889 return resultobj;
5890 fail:
5891 return NULL;
5892 }
5893
5894
5895 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5896 PyObject *resultobj;
5897 wxRect *arg1 = (wxRect *) 0 ;
5898 wxRect *arg2 = 0 ;
5899 wxRect result;
5900 wxRect temp2 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char *kwnames[] = {
5904 (char *) "self",(char *) "rect", NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5909 if (SWIG_arg_fail(1)) SWIG_fail;
5910 {
5911 arg2 = &temp2;
5912 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5913 }
5914 {
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 wxRect * resultptr;
5923 resultptr = new wxRect((wxRect &)(result));
5924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5925 }
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj;
5934 wxRect *arg1 = (wxRect *) 0 ;
5935 wxRect *arg2 = 0 ;
5936 wxRect *result;
5937 wxRect temp2 ;
5938 PyObject * obj0 = 0 ;
5939 PyObject * obj1 = 0 ;
5940 char *kwnames[] = {
5941 (char *) "self",(char *) "rect", NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5946 if (SWIG_arg_fail(1)) SWIG_fail;
5947 {
5948 arg2 = &temp2;
5949 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5950 }
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 {
5954 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5955 result = (wxRect *) &_result_ref;
5956 }
5957
5958 wxPyEndAllowThreads(__tstate);
5959 if (PyErr_Occurred()) SWIG_fail;
5960 }
5961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5962 return resultobj;
5963 fail:
5964 return NULL;
5965 }
5966
5967
5968 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5969 PyObject *resultobj;
5970 wxRect *arg1 = (wxRect *) 0 ;
5971 wxRect *arg2 = 0 ;
5972 bool result;
5973 wxRect temp2 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 char *kwnames[] = {
5977 (char *) "self",(char *) "rect", NULL
5978 };
5979
5980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5982 if (SWIG_arg_fail(1)) SWIG_fail;
5983 {
5984 arg2 = &temp2;
5985 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5986 }
5987 {
5988 PyThreadState* __tstate = wxPyBeginAllowThreads();
5989 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5990
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 {
5995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5996 }
5997 return resultobj;
5998 fail:
5999 return NULL;
6000 }
6001
6002
6003 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6004 PyObject *resultobj;
6005 wxRect *arg1 = (wxRect *) 0 ;
6006 wxRect *arg2 = 0 ;
6007 bool result;
6008 wxRect temp2 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 char *kwnames[] = {
6012 (char *) "self",(char *) "rect", NULL
6013 };
6014
6015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6017 if (SWIG_arg_fail(1)) SWIG_fail;
6018 {
6019 arg2 = &temp2;
6020 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6021 }
6022 {
6023 PyThreadState* __tstate = wxPyBeginAllowThreads();
6024 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6025
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 {
6030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6031 }
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 wxRect *arg1 = (wxRect *) 0 ;
6041 int arg2 ;
6042 int arg3 ;
6043 bool result;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 PyObject * obj2 = 0 ;
6047 char *kwnames[] = {
6048 (char *) "self",(char *) "x",(char *) "y", NULL
6049 };
6050
6051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6053 if (SWIG_arg_fail(1)) SWIG_fail;
6054 {
6055 arg2 = (int)(SWIG_As_int(obj1));
6056 if (SWIG_arg_fail(2)) SWIG_fail;
6057 }
6058 {
6059 arg3 = (int)(SWIG_As_int(obj2));
6060 if (SWIG_arg_fail(3)) SWIG_fail;
6061 }
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6065
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 {
6070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6071 }
6072 return resultobj;
6073 fail:
6074 return NULL;
6075 }
6076
6077
6078 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6079 PyObject *resultobj;
6080 wxRect *arg1 = (wxRect *) 0 ;
6081 wxPoint *arg2 = 0 ;
6082 bool result;
6083 wxPoint temp2 ;
6084 PyObject * obj0 = 0 ;
6085 PyObject * obj1 = 0 ;
6086 char *kwnames[] = {
6087 (char *) "self",(char *) "pt", NULL
6088 };
6089
6090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6092 if (SWIG_arg_fail(1)) SWIG_fail;
6093 {
6094 arg2 = &temp2;
6095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6096 }
6097 {
6098 PyThreadState* __tstate = wxPyBeginAllowThreads();
6099 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6100
6101 wxPyEndAllowThreads(__tstate);
6102 if (PyErr_Occurred()) SWIG_fail;
6103 }
6104 {
6105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6106 }
6107 return resultobj;
6108 fail:
6109 return NULL;
6110 }
6111
6112
6113 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6114 PyObject *resultobj;
6115 wxRect *arg1 = (wxRect *) 0 ;
6116 wxRect *arg2 = 0 ;
6117 bool result;
6118 wxRect temp2 ;
6119 PyObject * obj0 = 0 ;
6120 PyObject * obj1 = 0 ;
6121 char *kwnames[] = {
6122 (char *) "self",(char *) "rect", NULL
6123 };
6124
6125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6127 if (SWIG_arg_fail(1)) SWIG_fail;
6128 {
6129 arg2 = &temp2;
6130 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6131 }
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6135
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6141 }
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxRect *arg1 = (wxRect *) 0 ;
6151 int arg2 ;
6152 PyObject * obj0 = 0 ;
6153 PyObject * obj1 = 0 ;
6154 char *kwnames[] = {
6155 (char *) "self",(char *) "x", NULL
6156 };
6157
6158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6160 if (SWIG_arg_fail(1)) SWIG_fail;
6161 {
6162 arg2 = (int)(SWIG_As_int(obj1));
6163 if (SWIG_arg_fail(2)) SWIG_fail;
6164 }
6165 if (arg1) (arg1)->x = arg2;
6166
6167 Py_INCREF(Py_None); resultobj = Py_None;
6168 return resultobj;
6169 fail:
6170 return NULL;
6171 }
6172
6173
6174 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6175 PyObject *resultobj;
6176 wxRect *arg1 = (wxRect *) 0 ;
6177 int result;
6178 PyObject * obj0 = 0 ;
6179 char *kwnames[] = {
6180 (char *) "self", NULL
6181 };
6182
6183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6185 if (SWIG_arg_fail(1)) SWIG_fail;
6186 result = (int) ((arg1)->x);
6187
6188 {
6189 resultobj = SWIG_From_int((int)(result));
6190 }
6191 return resultobj;
6192 fail:
6193 return NULL;
6194 }
6195
6196
6197 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6198 PyObject *resultobj;
6199 wxRect *arg1 = (wxRect *) 0 ;
6200 int arg2 ;
6201 PyObject * obj0 = 0 ;
6202 PyObject * obj1 = 0 ;
6203 char *kwnames[] = {
6204 (char *) "self",(char *) "y", NULL
6205 };
6206
6207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6209 if (SWIG_arg_fail(1)) SWIG_fail;
6210 {
6211 arg2 = (int)(SWIG_As_int(obj1));
6212 if (SWIG_arg_fail(2)) SWIG_fail;
6213 }
6214 if (arg1) (arg1)->y = arg2;
6215
6216 Py_INCREF(Py_None); resultobj = Py_None;
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj;
6225 wxRect *arg1 = (wxRect *) 0 ;
6226 int result;
6227 PyObject * obj0 = 0 ;
6228 char *kwnames[] = {
6229 (char *) "self", NULL
6230 };
6231
6232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6234 if (SWIG_arg_fail(1)) SWIG_fail;
6235 result = (int) ((arg1)->y);
6236
6237 {
6238 resultobj = SWIG_From_int((int)(result));
6239 }
6240 return resultobj;
6241 fail:
6242 return NULL;
6243 }
6244
6245
6246 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6247 PyObject *resultobj;
6248 wxRect *arg1 = (wxRect *) 0 ;
6249 int arg2 ;
6250 PyObject * obj0 = 0 ;
6251 PyObject * obj1 = 0 ;
6252 char *kwnames[] = {
6253 (char *) "self",(char *) "width", NULL
6254 };
6255
6256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6258 if (SWIG_arg_fail(1)) SWIG_fail;
6259 {
6260 arg2 = (int)(SWIG_As_int(obj1));
6261 if (SWIG_arg_fail(2)) SWIG_fail;
6262 }
6263 if (arg1) (arg1)->width = arg2;
6264
6265 Py_INCREF(Py_None); resultobj = Py_None;
6266 return resultobj;
6267 fail:
6268 return NULL;
6269 }
6270
6271
6272 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6273 PyObject *resultobj;
6274 wxRect *arg1 = (wxRect *) 0 ;
6275 int result;
6276 PyObject * obj0 = 0 ;
6277 char *kwnames[] = {
6278 (char *) "self", NULL
6279 };
6280
6281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6283 if (SWIG_arg_fail(1)) SWIG_fail;
6284 result = (int) ((arg1)->width);
6285
6286 {
6287 resultobj = SWIG_From_int((int)(result));
6288 }
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj;
6297 wxRect *arg1 = (wxRect *) 0 ;
6298 int arg2 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char *kwnames[] = {
6302 (char *) "self",(char *) "height", NULL
6303 };
6304
6305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 {
6309 arg2 = (int)(SWIG_As_int(obj1));
6310 if (SWIG_arg_fail(2)) SWIG_fail;
6311 }
6312 if (arg1) (arg1)->height = arg2;
6313
6314 Py_INCREF(Py_None); resultobj = Py_None;
6315 return resultobj;
6316 fail:
6317 return NULL;
6318 }
6319
6320
6321 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj;
6323 wxRect *arg1 = (wxRect *) 0 ;
6324 int result;
6325 PyObject * obj0 = 0 ;
6326 char *kwnames[] = {
6327 (char *) "self", NULL
6328 };
6329
6330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6332 if (SWIG_arg_fail(1)) SWIG_fail;
6333 result = (int) ((arg1)->height);
6334
6335 {
6336 resultobj = SWIG_From_int((int)(result));
6337 }
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int arg2 = (int) 0 ;
6348 int arg3 = (int) 0 ;
6349 int arg4 = (int) 0 ;
6350 int arg5 = (int) 0 ;
6351 PyObject * obj0 = 0 ;
6352 PyObject * obj1 = 0 ;
6353 PyObject * obj2 = 0 ;
6354 PyObject * obj3 = 0 ;
6355 PyObject * obj4 = 0 ;
6356 char *kwnames[] = {
6357 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6358 };
6359
6360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6362 if (SWIG_arg_fail(1)) SWIG_fail;
6363 if (obj1) {
6364 {
6365 arg2 = (int)(SWIG_As_int(obj1));
6366 if (SWIG_arg_fail(2)) SWIG_fail;
6367 }
6368 }
6369 if (obj2) {
6370 {
6371 arg3 = (int)(SWIG_As_int(obj2));
6372 if (SWIG_arg_fail(3)) SWIG_fail;
6373 }
6374 }
6375 if (obj3) {
6376 {
6377 arg4 = (int)(SWIG_As_int(obj3));
6378 if (SWIG_arg_fail(4)) SWIG_fail;
6379 }
6380 }
6381 if (obj4) {
6382 {
6383 arg5 = (int)(SWIG_As_int(obj4));
6384 if (SWIG_arg_fail(5)) SWIG_fail;
6385 }
6386 }
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6390
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 Py_INCREF(Py_None); resultobj = Py_None;
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 PyObject *result;
6405 PyObject * obj0 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "self", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (PyObject *)wxRect_Get(arg1);
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 resultobj = result;
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6428 PyObject *obj;
6429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6430 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6431 Py_INCREF(obj);
6432 return Py_BuildValue((char *)"");
6433 }
6434 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6435 PyObject *resultobj;
6436 wxRect *arg1 = (wxRect *) 0 ;
6437 wxRect *arg2 = (wxRect *) 0 ;
6438 PyObject *result;
6439 PyObject * obj0 = 0 ;
6440 PyObject * obj1 = 0 ;
6441 char *kwnames[] = {
6442 (char *) "r1",(char *) "r2", NULL
6443 };
6444
6445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6447 if (SWIG_arg_fail(1)) SWIG_fail;
6448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(2)) SWIG_fail;
6450 {
6451 if (!wxPyCheckForApp()) SWIG_fail;
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (PyObject *)wxIntersectRect(arg1,arg2);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = result;
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj;
6467 double arg1 = (double) 0.0 ;
6468 double arg2 = (double) 0.0 ;
6469 wxPoint2D *result;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char *kwnames[] = {
6473 (char *) "x",(char *) "y", NULL
6474 };
6475
6476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6477 if (obj0) {
6478 {
6479 arg1 = (double)(SWIG_As_double(obj0));
6480 if (SWIG_arg_fail(1)) SWIG_fail;
6481 }
6482 }
6483 if (obj1) {
6484 {
6485 arg2 = (double)(SWIG_As_double(obj1));
6486 if (SWIG_arg_fail(2)) SWIG_fail;
6487 }
6488 }
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj;
6505 wxPoint2D *arg1 = 0 ;
6506 wxPoint2D *result;
6507 wxPoint2D temp1 ;
6508 PyObject * obj0 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "pt", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6514 {
6515 arg1 = &temp1;
6516 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6517 }
6518 {
6519 PyThreadState* __tstate = wxPyBeginAllowThreads();
6520 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6521
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj;
6534 wxPoint *arg1 = 0 ;
6535 wxPoint2D *result;
6536 wxPoint temp1 ;
6537 PyObject * obj0 = 0 ;
6538 char *kwnames[] = {
6539 (char *) "pt", NULL
6540 };
6541
6542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6543 {
6544 arg1 = &temp1;
6545 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6546 }
6547 {
6548 PyThreadState* __tstate = wxPyBeginAllowThreads();
6549 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6550
6551 wxPyEndAllowThreads(__tstate);
6552 if (PyErr_Occurred()) SWIG_fail;
6553 }
6554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj;
6563 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6564 int *arg2 = (int *) 0 ;
6565 int *arg3 = (int *) 0 ;
6566 int temp2 ;
6567 int res2 = 0 ;
6568 int temp3 ;
6569 int res3 = 0 ;
6570 PyObject * obj0 = 0 ;
6571 char *kwnames[] = {
6572 (char *) "self", NULL
6573 };
6574
6575 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6576 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6583
6584 wxPyEndAllowThreads(__tstate);
6585 if (PyErr_Occurred()) SWIG_fail;
6586 }
6587 Py_INCREF(Py_None); resultobj = Py_None;
6588 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6589 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6590 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6591 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6601 int *arg2 = (int *) 0 ;
6602 int *arg3 = (int *) 0 ;
6603 int temp2 ;
6604 int res2 = 0 ;
6605 int temp3 ;
6606 int res3 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 char *kwnames[] = {
6609 (char *) "self", NULL
6610 };
6611
6612 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6613 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6616 if (SWIG_arg_fail(1)) SWIG_fail;
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 Py_INCREF(Py_None); resultobj = Py_None;
6625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6627 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6628 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj;
6637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6638 double result;
6639 PyObject * obj0 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self", NULL
6642 };
6643
6644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6646 if (SWIG_arg_fail(1)) SWIG_fail;
6647 {
6648 PyThreadState* __tstate = wxPyBeginAllowThreads();
6649 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6650
6651 wxPyEndAllowThreads(__tstate);
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 {
6655 resultobj = SWIG_From_double((double)(result));
6656 }
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj;
6665 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6666 double result;
6667 PyObject * obj0 = 0 ;
6668 char *kwnames[] = {
6669 (char *) "self", NULL
6670 };
6671
6672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(1)) SWIG_fail;
6675 {
6676 PyThreadState* __tstate = wxPyBeginAllowThreads();
6677 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6678
6679 wxPyEndAllowThreads(__tstate);
6680 if (PyErr_Occurred()) SWIG_fail;
6681 }
6682 {
6683 resultobj = SWIG_From_double((double)(result));
6684 }
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6692 PyObject *resultobj;
6693 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6694 double arg2 ;
6695 PyObject * obj0 = 0 ;
6696 PyObject * obj1 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "self",(char *) "length", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6703 if (SWIG_arg_fail(1)) SWIG_fail;
6704 {
6705 arg2 = (double)(SWIG_As_double(obj1));
6706 if (SWIG_arg_fail(2)) SWIG_fail;
6707 }
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 (arg1)->SetVectorLength(arg2);
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 Py_INCREF(Py_None); resultobj = Py_None;
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj;
6724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6725 double arg2 ;
6726 PyObject * obj0 = 0 ;
6727 PyObject * obj1 = 0 ;
6728 char *kwnames[] = {
6729 (char *) "self",(char *) "degrees", NULL
6730 };
6731
6732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6734 if (SWIG_arg_fail(1)) SWIG_fail;
6735 {
6736 arg2 = (double)(SWIG_As_double(obj1));
6737 if (SWIG_arg_fail(2)) SWIG_fail;
6738 }
6739 {
6740 PyThreadState* __tstate = wxPyBeginAllowThreads();
6741 (arg1)->SetVectorAngle(arg2);
6742
6743 wxPyEndAllowThreads(__tstate);
6744 if (PyErr_Occurred()) SWIG_fail;
6745 }
6746 Py_INCREF(Py_None); resultobj = Py_None;
6747 return resultobj;
6748 fail:
6749 return NULL;
6750 }
6751
6752
6753 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6754 PyObject *resultobj;
6755 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6756 wxPoint2D *arg2 = 0 ;
6757 double result;
6758 wxPoint2D temp2 ;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 char *kwnames[] = {
6762 (char *) "self",(char *) "pt", NULL
6763 };
6764
6765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6767 if (SWIG_arg_fail(1)) SWIG_fail;
6768 {
6769 arg2 = &temp2;
6770 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6771 }
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6775
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 {
6780 resultobj = SWIG_From_double((double)(result));
6781 }
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj;
6790 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6791 wxPoint2D *arg2 = 0 ;
6792 double result;
6793 wxPoint2D temp2 ;
6794 PyObject * obj0 = 0 ;
6795 PyObject * obj1 = 0 ;
6796 char *kwnames[] = {
6797 (char *) "self",(char *) "pt", NULL
6798 };
6799
6800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6802 if (SWIG_arg_fail(1)) SWIG_fail;
6803 {
6804 arg2 = &temp2;
6805 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6806 }
6807 {
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6810
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 {
6815 resultobj = SWIG_From_double((double)(result));
6816 }
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj;
6825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6826 wxPoint2D *arg2 = 0 ;
6827 double result;
6828 wxPoint2D temp2 ;
6829 PyObject * obj0 = 0 ;
6830 PyObject * obj1 = 0 ;
6831 char *kwnames[] = {
6832 (char *) "self",(char *) "vec", NULL
6833 };
6834
6835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6837 if (SWIG_arg_fail(1)) SWIG_fail;
6838 {
6839 arg2 = &temp2;
6840 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6841 }
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 {
6850 resultobj = SWIG_From_double((double)(result));
6851 }
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6859 PyObject *resultobj;
6860 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6861 wxPoint2D *arg2 = 0 ;
6862 double result;
6863 wxPoint2D temp2 ;
6864 PyObject * obj0 = 0 ;
6865 PyObject * obj1 = 0 ;
6866 char *kwnames[] = {
6867 (char *) "self",(char *) "vec", NULL
6868 };
6869
6870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6872 if (SWIG_arg_fail(1)) SWIG_fail;
6873 {
6874 arg2 = &temp2;
6875 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6876 }
6877 {
6878 PyThreadState* __tstate = wxPyBeginAllowThreads();
6879 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6880
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 {
6885 resultobj = SWIG_From_double((double)(result));
6886 }
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6894 PyObject *resultobj;
6895 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6896 wxPoint2D result;
6897 PyObject * obj0 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "self", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6904 if (SWIG_arg_fail(1)) SWIG_fail;
6905 {
6906 PyThreadState* __tstate = wxPyBeginAllowThreads();
6907 result = (arg1)->operator -();
6908
6909 wxPyEndAllowThreads(__tstate);
6910 if (PyErr_Occurred()) SWIG_fail;
6911 }
6912 {
6913 wxPoint2D * resultptr;
6914 resultptr = new wxPoint2D((wxPoint2D &)(result));
6915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6916 }
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj;
6925 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6926 wxPoint2D *arg2 = 0 ;
6927 wxPoint2D *result;
6928 wxPoint2D temp2 ;
6929 PyObject * obj0 = 0 ;
6930 PyObject * obj1 = 0 ;
6931 char *kwnames[] = {
6932 (char *) "self",(char *) "pt", NULL
6933 };
6934
6935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6937 if (SWIG_arg_fail(1)) SWIG_fail;
6938 {
6939 arg2 = &temp2;
6940 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6941 }
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 {
6945 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6946 result = (wxPoint2D *) &_result_ref;
6947 }
6948
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj;
6961 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6962 wxPoint2D *arg2 = 0 ;
6963 wxPoint2D *result;
6964 wxPoint2D temp2 ;
6965 PyObject * obj0 = 0 ;
6966 PyObject * obj1 = 0 ;
6967 char *kwnames[] = {
6968 (char *) "self",(char *) "pt", NULL
6969 };
6970
6971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 {
6975 arg2 = &temp2;
6976 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6977 }
6978 {
6979 PyThreadState* __tstate = wxPyBeginAllowThreads();
6980 {
6981 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6982 result = (wxPoint2D *) &_result_ref;
6983 }
6984
6985 wxPyEndAllowThreads(__tstate);
6986 if (PyErr_Occurred()) SWIG_fail;
6987 }
6988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6989 return resultobj;
6990 fail:
6991 return NULL;
6992 }
6993
6994
6995 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj;
6997 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6998 wxPoint2D *arg2 = 0 ;
6999 wxPoint2D *result;
7000 wxPoint2D temp2 ;
7001 PyObject * obj0 = 0 ;
7002 PyObject * obj1 = 0 ;
7003 char *kwnames[] = {
7004 (char *) "self",(char *) "pt", NULL
7005 };
7006
7007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7009 if (SWIG_arg_fail(1)) SWIG_fail;
7010 {
7011 arg2 = &temp2;
7012 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7013 }
7014 {
7015 PyThreadState* __tstate = wxPyBeginAllowThreads();
7016 {
7017 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7018 result = (wxPoint2D *) &_result_ref;
7019 }
7020
7021 wxPyEndAllowThreads(__tstate);
7022 if (PyErr_Occurred()) SWIG_fail;
7023 }
7024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7025 return resultobj;
7026 fail:
7027 return NULL;
7028 }
7029
7030
7031 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7032 PyObject *resultobj;
7033 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7034 wxPoint2D *arg2 = 0 ;
7035 wxPoint2D *result;
7036 wxPoint2D temp2 ;
7037 PyObject * obj0 = 0 ;
7038 PyObject * obj1 = 0 ;
7039 char *kwnames[] = {
7040 (char *) "self",(char *) "pt", NULL
7041 };
7042
7043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7045 if (SWIG_arg_fail(1)) SWIG_fail;
7046 {
7047 arg2 = &temp2;
7048 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7049 }
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 {
7053 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7054 result = (wxPoint2D *) &_result_ref;
7055 }
7056
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7061 return resultobj;
7062 fail:
7063 return NULL;
7064 }
7065
7066
7067 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7068 PyObject *resultobj;
7069 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7070 wxPoint2D *arg2 = 0 ;
7071 bool result;
7072 wxPoint2D temp2 ;
7073 PyObject * obj0 = 0 ;
7074 PyObject * obj1 = 0 ;
7075 char *kwnames[] = {
7076 (char *) "self",(char *) "pt", NULL
7077 };
7078
7079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7081 if (SWIG_arg_fail(1)) SWIG_fail;
7082 {
7083 arg2 = &temp2;
7084 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7085 }
7086 {
7087 PyThreadState* __tstate = wxPyBeginAllowThreads();
7088 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7089
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 {
7094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7095 }
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7103 PyObject *resultobj;
7104 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7105 wxPoint2D *arg2 = 0 ;
7106 bool result;
7107 wxPoint2D temp2 ;
7108 PyObject * obj0 = 0 ;
7109 PyObject * obj1 = 0 ;
7110 char *kwnames[] = {
7111 (char *) "self",(char *) "pt", NULL
7112 };
7113
7114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7116 if (SWIG_arg_fail(1)) SWIG_fail;
7117 {
7118 arg2 = &temp2;
7119 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7120 }
7121 {
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7124
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 {
7129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7130 }
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7138 PyObject *resultobj;
7139 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7140 double arg2 ;
7141 PyObject * obj0 = 0 ;
7142 PyObject * obj1 = 0 ;
7143 char *kwnames[] = {
7144 (char *) "self",(char *) "m_x", NULL
7145 };
7146
7147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7149 if (SWIG_arg_fail(1)) SWIG_fail;
7150 {
7151 arg2 = (double)(SWIG_As_double(obj1));
7152 if (SWIG_arg_fail(2)) SWIG_fail;
7153 }
7154 if (arg1) (arg1)->m_x = arg2;
7155
7156 Py_INCREF(Py_None); resultobj = Py_None;
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj;
7165 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7166 double result;
7167 PyObject * obj0 = 0 ;
7168 char *kwnames[] = {
7169 (char *) "self", NULL
7170 };
7171
7172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7174 if (SWIG_arg_fail(1)) SWIG_fail;
7175 result = (double) ((arg1)->m_x);
7176
7177 {
7178 resultobj = SWIG_From_double((double)(result));
7179 }
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj;
7188 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7189 double arg2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char *kwnames[] = {
7193 (char *) "self",(char *) "m_y", NULL
7194 };
7195
7196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7198 if (SWIG_arg_fail(1)) SWIG_fail;
7199 {
7200 arg2 = (double)(SWIG_As_double(obj1));
7201 if (SWIG_arg_fail(2)) SWIG_fail;
7202 }
7203 if (arg1) (arg1)->m_y = arg2;
7204
7205 Py_INCREF(Py_None); resultobj = Py_None;
7206 return resultobj;
7207 fail:
7208 return NULL;
7209 }
7210
7211
7212 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7213 PyObject *resultobj;
7214 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7215 double result;
7216 PyObject * obj0 = 0 ;
7217 char *kwnames[] = {
7218 (char *) "self", NULL
7219 };
7220
7221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7223 if (SWIG_arg_fail(1)) SWIG_fail;
7224 result = (double) ((arg1)->m_y);
7225
7226 {
7227 resultobj = SWIG_From_double((double)(result));
7228 }
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj;
7237 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7238 double arg2 = (double) 0 ;
7239 double arg3 = (double) 0 ;
7240 PyObject * obj0 = 0 ;
7241 PyObject * obj1 = 0 ;
7242 PyObject * obj2 = 0 ;
7243 char *kwnames[] = {
7244 (char *) "self",(char *) "x",(char *) "y", NULL
7245 };
7246
7247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7249 if (SWIG_arg_fail(1)) SWIG_fail;
7250 if (obj1) {
7251 {
7252 arg2 = (double)(SWIG_As_double(obj1));
7253 if (SWIG_arg_fail(2)) SWIG_fail;
7254 }
7255 }
7256 if (obj2) {
7257 {
7258 arg3 = (double)(SWIG_As_double(obj2));
7259 if (SWIG_arg_fail(3)) SWIG_fail;
7260 }
7261 }
7262 {
7263 PyThreadState* __tstate = wxPyBeginAllowThreads();
7264 wxPoint2D_Set(arg1,arg2,arg3);
7265
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 Py_INCREF(Py_None); resultobj = Py_None;
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj;
7278 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7279 PyObject *result;
7280 PyObject * obj0 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 result = (PyObject *)wxPoint2D_Get(arg1);
7291
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 resultobj = result;
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7303 PyObject *obj;
7304 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7305 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7306 Py_INCREF(obj);
7307 return Py_BuildValue((char *)"");
7308 }
7309 static int _wrap_DefaultPosition_set(PyObject *) {
7310 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7311 return 1;
7312 }
7313
7314
7315 static PyObject *_wrap_DefaultPosition_get(void) {
7316 PyObject *pyobj;
7317
7318 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7319 return pyobj;
7320 }
7321
7322
7323 static int _wrap_DefaultSize_set(PyObject *) {
7324 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7325 return 1;
7326 }
7327
7328
7329 static PyObject *_wrap_DefaultSize_get(void) {
7330 PyObject *pyobj;
7331
7332 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7333 return pyobj;
7334 }
7335
7336
7337 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7338 PyObject *resultobj;
7339 PyObject *arg1 = (PyObject *) 0 ;
7340 wxPyInputStream *result;
7341 PyObject * obj0 = 0 ;
7342 char *kwnames[] = {
7343 (char *) "p", NULL
7344 };
7345
7346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7347 arg1 = obj0;
7348 {
7349 PyThreadState* __tstate = wxPyBeginAllowThreads();
7350 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7351
7352 wxPyEndAllowThreads(__tstate);
7353 if (PyErr_Occurred()) SWIG_fail;
7354 }
7355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7356 return resultobj;
7357 fail:
7358 return NULL;
7359 }
7360
7361
7362 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7363 PyObject *resultobj;
7364 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7365 PyObject * obj0 = 0 ;
7366 char *kwnames[] = {
7367 (char *) "self", NULL
7368 };
7369
7370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7372 if (SWIG_arg_fail(1)) SWIG_fail;
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 delete arg1;
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 Py_INCREF(Py_None); resultobj = Py_None;
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7390 PyObject * obj0 = 0 ;
7391 char *kwnames[] = {
7392 (char *) "self", NULL
7393 };
7394
7395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7397 if (SWIG_arg_fail(1)) SWIG_fail;
7398 {
7399 PyThreadState* __tstate = wxPyBeginAllowThreads();
7400 (arg1)->close();
7401
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 Py_INCREF(Py_None); resultobj = Py_None;
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj;
7414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7415 PyObject * obj0 = 0 ;
7416 char *kwnames[] = {
7417 (char *) "self", NULL
7418 };
7419
7420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7422 if (SWIG_arg_fail(1)) SWIG_fail;
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 (arg1)->flush();
7426
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 Py_INCREF(Py_None); resultobj = Py_None;
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj;
7439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7440 bool result;
7441 PyObject * obj0 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->eof();
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj;
7467 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7468 int arg2 = (int) -1 ;
7469 PyObject *result;
7470 PyObject * obj0 = 0 ;
7471 PyObject * obj1 = 0 ;
7472 char *kwnames[] = {
7473 (char *) "self",(char *) "size", NULL
7474 };
7475
7476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7478 if (SWIG_arg_fail(1)) SWIG_fail;
7479 if (obj1) {
7480 {
7481 arg2 = (int)(SWIG_As_int(obj1));
7482 if (SWIG_arg_fail(2)) SWIG_fail;
7483 }
7484 }
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 result = (PyObject *)(arg1)->read(arg2);
7488
7489 wxPyEndAllowThreads(__tstate);
7490 if (PyErr_Occurred()) SWIG_fail;
7491 }
7492 resultobj = result;
7493 return resultobj;
7494 fail:
7495 return NULL;
7496 }
7497
7498
7499 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7500 PyObject *resultobj;
7501 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7502 int arg2 = (int) -1 ;
7503 PyObject *result;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self",(char *) "size", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 if (obj1) {
7514 {
7515 arg2 = (int)(SWIG_As_int(obj1));
7516 if (SWIG_arg_fail(2)) SWIG_fail;
7517 }
7518 }
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 result = (PyObject *)(arg1)->readline(arg2);
7522
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 resultobj = result;
7527 return resultobj;
7528 fail:
7529 return NULL;
7530 }
7531
7532
7533 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7534 PyObject *resultobj;
7535 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7536 int arg2 = (int) -1 ;
7537 PyObject *result;
7538 PyObject * obj0 = 0 ;
7539 PyObject * obj1 = 0 ;
7540 char *kwnames[] = {
7541 (char *) "self",(char *) "sizehint", NULL
7542 };
7543
7544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7546 if (SWIG_arg_fail(1)) SWIG_fail;
7547 if (obj1) {
7548 {
7549 arg2 = (int)(SWIG_As_int(obj1));
7550 if (SWIG_arg_fail(2)) SWIG_fail;
7551 }
7552 }
7553 {
7554 PyThreadState* __tstate = wxPyBeginAllowThreads();
7555 result = (PyObject *)(arg1)->readlines(arg2);
7556
7557 wxPyEndAllowThreads(__tstate);
7558 if (PyErr_Occurred()) SWIG_fail;
7559 }
7560 resultobj = result;
7561 return resultobj;
7562 fail:
7563 return NULL;
7564 }
7565
7566
7567 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7568 PyObject *resultobj;
7569 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7570 int arg2 ;
7571 int arg3 = (int) 0 ;
7572 PyObject * obj0 = 0 ;
7573 PyObject * obj1 = 0 ;
7574 PyObject * obj2 = 0 ;
7575 char *kwnames[] = {
7576 (char *) "self",(char *) "offset",(char *) "whence", NULL
7577 };
7578
7579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7581 if (SWIG_arg_fail(1)) SWIG_fail;
7582 {
7583 arg2 = (int)(SWIG_As_int(obj1));
7584 if (SWIG_arg_fail(2)) SWIG_fail;
7585 }
7586 if (obj2) {
7587 {
7588 arg3 = (int)(SWIG_As_int(obj2));
7589 if (SWIG_arg_fail(3)) SWIG_fail;
7590 }
7591 }
7592 {
7593 PyThreadState* __tstate = wxPyBeginAllowThreads();
7594 (arg1)->seek(arg2,arg3);
7595
7596 wxPyEndAllowThreads(__tstate);
7597 if (PyErr_Occurred()) SWIG_fail;
7598 }
7599 Py_INCREF(Py_None); resultobj = Py_None;
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj;
7608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7609 int result;
7610 PyObject * obj0 = 0 ;
7611 char *kwnames[] = {
7612 (char *) "self", NULL
7613 };
7614
7615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7617 if (SWIG_arg_fail(1)) SWIG_fail;
7618 {
7619 PyThreadState* __tstate = wxPyBeginAllowThreads();
7620 result = (int)(arg1)->tell();
7621
7622 wxPyEndAllowThreads(__tstate);
7623 if (PyErr_Occurred()) SWIG_fail;
7624 }
7625 {
7626 resultobj = SWIG_From_int((int)(result));
7627 }
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj;
7636 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7637 char result;
7638 PyObject * obj0 = 0 ;
7639 char *kwnames[] = {
7640 (char *) "self", NULL
7641 };
7642
7643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7645 if (SWIG_arg_fail(1)) SWIG_fail;
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (char)(arg1)->Peek();
7649
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 {
7654 resultobj = SWIG_From_char((char)(result));
7655 }
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj;
7664 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7665 char result;
7666 PyObject * obj0 = 0 ;
7667 char *kwnames[] = {
7668 (char *) "self", NULL
7669 };
7670
7671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7673 if (SWIG_arg_fail(1)) SWIG_fail;
7674 {
7675 PyThreadState* __tstate = wxPyBeginAllowThreads();
7676 result = (char)(arg1)->GetC();
7677
7678 wxPyEndAllowThreads(__tstate);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 {
7682 resultobj = SWIG_From_char((char)(result));
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj;
7692 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7693 size_t result;
7694 PyObject * obj0 = 0 ;
7695 char *kwnames[] = {
7696 (char *) "self", NULL
7697 };
7698
7699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7701 if (SWIG_arg_fail(1)) SWIG_fail;
7702 {
7703 PyThreadState* __tstate = wxPyBeginAllowThreads();
7704 result = (size_t)(arg1)->LastRead();
7705
7706 wxPyEndAllowThreads(__tstate);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj;
7720 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7721 bool result;
7722 PyObject * obj0 = 0 ;
7723 char *kwnames[] = {
7724 (char *) "self", NULL
7725 };
7726
7727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7729 if (SWIG_arg_fail(1)) SWIG_fail;
7730 {
7731 PyThreadState* __tstate = wxPyBeginAllowThreads();
7732 result = (bool)(arg1)->CanRead();
7733
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 {
7738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7739 }
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj;
7748 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7749 bool result;
7750 PyObject * obj0 = 0 ;
7751 char *kwnames[] = {
7752 (char *) "self", NULL
7753 };
7754
7755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7757 if (SWIG_arg_fail(1)) SWIG_fail;
7758 {
7759 PyThreadState* __tstate = wxPyBeginAllowThreads();
7760 result = (bool)(arg1)->Eof();
7761
7762 wxPyEndAllowThreads(__tstate);
7763 if (PyErr_Occurred()) SWIG_fail;
7764 }
7765 {
7766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7767 }
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7775 PyObject *resultobj;
7776 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7777 char arg2 ;
7778 bool result;
7779 PyObject * obj0 = 0 ;
7780 PyObject * obj1 = 0 ;
7781 char *kwnames[] = {
7782 (char *) "self",(char *) "c", NULL
7783 };
7784
7785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7787 if (SWIG_arg_fail(1)) SWIG_fail;
7788 {
7789 arg2 = (char)(SWIG_As_char(obj1));
7790 if (SWIG_arg_fail(2)) SWIG_fail;
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (bool)(arg1)->Ungetch(arg2);
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7809 PyObject *resultobj;
7810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7811 long arg2 ;
7812 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7813 long result;
7814 PyObject * obj0 = 0 ;
7815 PyObject * obj1 = 0 ;
7816 PyObject * obj2 = 0 ;
7817 char *kwnames[] = {
7818 (char *) "self",(char *) "pos",(char *) "mode", NULL
7819 };
7820
7821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7823 if (SWIG_arg_fail(1)) SWIG_fail;
7824 {
7825 arg2 = (long)(SWIG_As_long(obj1));
7826 if (SWIG_arg_fail(2)) SWIG_fail;
7827 }
7828 if (obj2) {
7829 {
7830 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7831 if (SWIG_arg_fail(3)) SWIG_fail;
7832 }
7833 }
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = SWIG_From_long((long)(result));
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7853 long result;
7854 PyObject * obj0 = 0 ;
7855 char *kwnames[] = {
7856 (char *) "self", NULL
7857 };
7858
7859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7861 if (SWIG_arg_fail(1)) SWIG_fail;
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (long)(arg1)->TellI();
7865
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 {
7870 resultobj = SWIG_From_long((long)(result));
7871 }
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7879 PyObject *obj;
7880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7881 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7882 Py_INCREF(obj);
7883 return Py_BuildValue((char *)"");
7884 }
7885 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7886 PyObject *resultobj;
7887 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7888 PyObject *arg2 = (PyObject *) 0 ;
7889 PyObject * obj0 = 0 ;
7890 PyObject * obj1 = 0 ;
7891 char *kwnames[] = {
7892 (char *) "self",(char *) "obj", NULL
7893 };
7894
7895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7897 if (SWIG_arg_fail(1)) SWIG_fail;
7898 arg2 = obj1;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 wxOutputStream_write(arg1,arg2);
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 Py_INCREF(Py_None); resultobj = Py_None;
7907 return resultobj;
7908 fail:
7909 return NULL;
7910 }
7911
7912
7913 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7914 PyObject *obj;
7915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7916 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7917 Py_INCREF(obj);
7918 return Py_BuildValue((char *)"");
7919 }
7920 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj;
7922 wxInputStream *arg1 = (wxInputStream *) 0 ;
7923 wxString *arg2 = 0 ;
7924 wxString *arg3 = 0 ;
7925 wxString *arg4 = 0 ;
7926 wxDateTime arg5 ;
7927 wxFSFile *result;
7928 wxPyInputStream *temp1 ;
7929 bool temp2 = false ;
7930 bool temp3 = false ;
7931 bool temp4 = false ;
7932 PyObject * obj0 = 0 ;
7933 PyObject * obj1 = 0 ;
7934 PyObject * obj2 = 0 ;
7935 PyObject * obj3 = 0 ;
7936 PyObject * obj4 = 0 ;
7937 char *kwnames[] = {
7938 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7939 };
7940
7941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7942 {
7943 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7944 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7945 } else {
7946 PyErr_Clear(); // clear the failure of the wxPyConvert above
7947 arg1 = wxPyCBInputStream_create(obj0, true);
7948 if (arg1 == NULL) {
7949 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7950 SWIG_fail;
7951 }
7952 }
7953 }
7954 {
7955 arg2 = wxString_in_helper(obj1);
7956 if (arg2 == NULL) SWIG_fail;
7957 temp2 = true;
7958 }
7959 {
7960 arg3 = wxString_in_helper(obj2);
7961 if (arg3 == NULL) SWIG_fail;
7962 temp3 = true;
7963 }
7964 {
7965 arg4 = wxString_in_helper(obj3);
7966 if (arg4 == NULL) SWIG_fail;
7967 temp4 = true;
7968 }
7969 {
7970 wxDateTime * argp;
7971 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7972 if (SWIG_arg_fail(5)) SWIG_fail;
7973 if (argp == NULL) {
7974 SWIG_null_ref("wxDateTime");
7975 }
7976 if (SWIG_arg_fail(5)) SWIG_fail;
7977 arg5 = *argp;
7978 }
7979 {
7980 PyThreadState* __tstate = wxPyBeginAllowThreads();
7981 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7982
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 {
7987 resultobj = wxPyMake_wxObject(result, 1);
7988 }
7989 {
7990 if (temp2)
7991 delete arg2;
7992 }
7993 {
7994 if (temp3)
7995 delete arg3;
7996 }
7997 {
7998 if (temp4)
7999 delete arg4;
8000 }
8001 return resultobj;
8002 fail:
8003 {
8004 if (temp2)
8005 delete arg2;
8006 }
8007 {
8008 if (temp3)
8009 delete arg3;
8010 }
8011 {
8012 if (temp4)
8013 delete arg4;
8014 }
8015 return NULL;
8016 }
8017
8018
8019 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj;
8021 wxFSFile *arg1 = (wxFSFile *) 0 ;
8022 PyObject * obj0 = 0 ;
8023 char *kwnames[] = {
8024 (char *) "self", NULL
8025 };
8026
8027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8029 if (SWIG_arg_fail(1)) SWIG_fail;
8030 {
8031 PyThreadState* __tstate = wxPyBeginAllowThreads();
8032 delete arg1;
8033
8034 wxPyEndAllowThreads(__tstate);
8035 if (PyErr_Occurred()) SWIG_fail;
8036 }
8037 Py_INCREF(Py_None); resultobj = Py_None;
8038 return resultobj;
8039 fail:
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxFSFile *arg1 = (wxFSFile *) 0 ;
8047 wxInputStream *result;
8048 PyObject * obj0 = 0 ;
8049 char *kwnames[] = {
8050 (char *) "self", NULL
8051 };
8052
8053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8055 if (SWIG_arg_fail(1)) SWIG_fail;
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (wxInputStream *)(arg1)->GetStream();
8059
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 {
8064 wxPyInputStream * _ptr = NULL;
8065
8066 if (result) {
8067 _ptr = new wxPyInputStream(result);
8068 }
8069 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8070 }
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8078 PyObject *resultobj;
8079 wxFSFile *arg1 = (wxFSFile *) 0 ;
8080 wxString *result;
8081 PyObject * obj0 = 0 ;
8082 char *kwnames[] = {
8083 (char *) "self", NULL
8084 };
8085
8086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8088 if (SWIG_arg_fail(1)) SWIG_fail;
8089 {
8090 PyThreadState* __tstate = wxPyBeginAllowThreads();
8091 {
8092 wxString const &_result_ref = (arg1)->GetMimeType();
8093 result = (wxString *) &_result_ref;
8094 }
8095
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 {
8100 #if wxUSE_UNICODE
8101 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8102 #else
8103 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8104 #endif
8105 }
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8113 PyObject *resultobj;
8114 wxFSFile *arg1 = (wxFSFile *) 0 ;
8115 wxString *result;
8116 PyObject * obj0 = 0 ;
8117 char *kwnames[] = {
8118 (char *) "self", NULL
8119 };
8120
8121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8123 if (SWIG_arg_fail(1)) SWIG_fail;
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 {
8127 wxString const &_result_ref = (arg1)->GetLocation();
8128 result = (wxString *) &_result_ref;
8129 }
8130
8131 wxPyEndAllowThreads(__tstate);
8132 if (PyErr_Occurred()) SWIG_fail;
8133 }
8134 {
8135 #if wxUSE_UNICODE
8136 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8137 #else
8138 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8139 #endif
8140 }
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj;
8149 wxFSFile *arg1 = (wxFSFile *) 0 ;
8150 wxString *result;
8151 PyObject * obj0 = 0 ;
8152 char *kwnames[] = {
8153 (char *) "self", NULL
8154 };
8155
8156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8158 if (SWIG_arg_fail(1)) SWIG_fail;
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 {
8162 wxString const &_result_ref = (arg1)->GetAnchor();
8163 result = (wxString *) &_result_ref;
8164 }
8165
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 #if wxUSE_UNICODE
8171 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8172 #else
8173 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8174 #endif
8175 }
8176 return resultobj;
8177 fail:
8178 return NULL;
8179 }
8180
8181
8182 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8183 PyObject *resultobj;
8184 wxFSFile *arg1 = (wxFSFile *) 0 ;
8185 wxDateTime result;
8186 PyObject * obj0 = 0 ;
8187 char *kwnames[] = {
8188 (char *) "self", NULL
8189 };
8190
8191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8193 if (SWIG_arg_fail(1)) SWIG_fail;
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (arg1)->GetModificationTime();
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 {
8202 wxDateTime * resultptr;
8203 resultptr = new wxDateTime((wxDateTime &)(result));
8204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8205 }
8206 return resultobj;
8207 fail:
8208 return NULL;
8209 }
8210
8211
8212 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8213 PyObject *obj;
8214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8215 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8216 Py_INCREF(obj);
8217 return Py_BuildValue((char *)"");
8218 }
8219 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8220 PyObject *obj;
8221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8222 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8223 Py_INCREF(obj);
8224 return Py_BuildValue((char *)"");
8225 }
8226 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8227 PyObject *resultobj;
8228 wxPyFileSystemHandler *result;
8229 char *kwnames[] = {
8230 NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8251 PyObject *arg2 = (PyObject *) 0 ;
8252 PyObject *arg3 = (PyObject *) 0 ;
8253 PyObject * obj0 = 0 ;
8254 PyObject * obj1 = 0 ;
8255 PyObject * obj2 = 0 ;
8256 char *kwnames[] = {
8257 (char *) "self",(char *) "self",(char *) "_class", NULL
8258 };
8259
8260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = obj1;
8264 arg3 = obj2;
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 (arg1)->_setCallbackInfo(arg2,arg3);
8268
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 Py_INCREF(Py_None); resultobj = Py_None;
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8282 wxString *arg2 = 0 ;
8283 bool result;
8284 bool temp2 = false ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 char *kwnames[] = {
8288 (char *) "self",(char *) "location", NULL
8289 };
8290
8291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 {
8295 arg2 = wxString_in_helper(obj1);
8296 if (arg2 == NULL) SWIG_fail;
8297 temp2 = true;
8298 }
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8302
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 {
8307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8308 }
8309 {
8310 if (temp2)
8311 delete arg2;
8312 }
8313 return resultobj;
8314 fail:
8315 {
8316 if (temp2)
8317 delete arg2;
8318 }
8319 return NULL;
8320 }
8321
8322
8323 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj;
8325 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8326 wxFileSystem *arg2 = 0 ;
8327 wxString *arg3 = 0 ;
8328 wxFSFile *result;
8329 bool temp3 = false ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 PyObject * obj2 = 0 ;
8333 char *kwnames[] = {
8334 (char *) "self",(char *) "fs",(char *) "location", NULL
8335 };
8336
8337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8339 if (SWIG_arg_fail(1)) SWIG_fail;
8340 {
8341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8342 if (SWIG_arg_fail(2)) SWIG_fail;
8343 if (arg2 == NULL) {
8344 SWIG_null_ref("wxFileSystem");
8345 }
8346 if (SWIG_arg_fail(2)) SWIG_fail;
8347 }
8348 {
8349 arg3 = wxString_in_helper(obj2);
8350 if (arg3 == NULL) SWIG_fail;
8351 temp3 = true;
8352 }
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8356
8357 wxPyEndAllowThreads(__tstate);
8358 if (PyErr_Occurred()) SWIG_fail;
8359 }
8360 {
8361 resultobj = wxPyMake_wxObject(result, 1);
8362 }
8363 {
8364 if (temp3)
8365 delete arg3;
8366 }
8367 return resultobj;
8368 fail:
8369 {
8370 if (temp3)
8371 delete arg3;
8372 }
8373 return NULL;
8374 }
8375
8376
8377 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj;
8379 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8380 wxString *arg2 = 0 ;
8381 int arg3 = (int) 0 ;
8382 wxString result;
8383 bool temp2 = false ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 PyObject * obj2 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "spec",(char *) "flags", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 {
8395 arg2 = wxString_in_helper(obj1);
8396 if (arg2 == NULL) SWIG_fail;
8397 temp2 = true;
8398 }
8399 if (obj2) {
8400 {
8401 arg3 = (int)(SWIG_As_int(obj2));
8402 if (SWIG_arg_fail(3)) SWIG_fail;
8403 }
8404 }
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8408
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 {
8413 #if wxUSE_UNICODE
8414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8415 #else
8416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8417 #endif
8418 }
8419 {
8420 if (temp2)
8421 delete arg2;
8422 }
8423 return resultobj;
8424 fail:
8425 {
8426 if (temp2)
8427 delete arg2;
8428 }
8429 return NULL;
8430 }
8431
8432
8433 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8434 PyObject *resultobj;
8435 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8436 wxString result;
8437 PyObject * obj0 = 0 ;
8438 char *kwnames[] = {
8439 (char *) "self", NULL
8440 };
8441
8442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8444 if (SWIG_arg_fail(1)) SWIG_fail;
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 result = (arg1)->FindNext();
8448
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 {
8453 #if wxUSE_UNICODE
8454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8455 #else
8456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8457 #endif
8458 }
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8468 wxString *arg2 = 0 ;
8469 wxString result;
8470 bool temp2 = false ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 char *kwnames[] = {
8474 (char *) "self",(char *) "location", NULL
8475 };
8476
8477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8479 if (SWIG_arg_fail(1)) SWIG_fail;
8480 {
8481 arg2 = wxString_in_helper(obj1);
8482 if (arg2 == NULL) SWIG_fail;
8483 temp2 = true;
8484 }
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 result = (arg1)->GetProtocol((wxString const &)*arg2);
8488
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 {
8493 #if wxUSE_UNICODE
8494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8495 #else
8496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8497 #endif
8498 }
8499 {
8500 if (temp2)
8501 delete arg2;
8502 }
8503 return resultobj;
8504 fail:
8505 {
8506 if (temp2)
8507 delete arg2;
8508 }
8509 return NULL;
8510 }
8511
8512
8513 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8514 PyObject *resultobj;
8515 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8516 wxString *arg2 = 0 ;
8517 wxString result;
8518 bool temp2 = false ;
8519 PyObject * obj0 = 0 ;
8520 PyObject * obj1 = 0 ;
8521 char *kwnames[] = {
8522 (char *) "self",(char *) "location", NULL
8523 };
8524
8525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8527 if (SWIG_arg_fail(1)) SWIG_fail;
8528 {
8529 arg2 = wxString_in_helper(obj1);
8530 if (arg2 == NULL) SWIG_fail;
8531 temp2 = true;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8536
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 {
8541 #if wxUSE_UNICODE
8542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8543 #else
8544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8545 #endif
8546 }
8547 {
8548 if (temp2)
8549 delete arg2;
8550 }
8551 return resultobj;
8552 fail:
8553 {
8554 if (temp2)
8555 delete arg2;
8556 }
8557 return NULL;
8558 }
8559
8560
8561 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8562 PyObject *resultobj;
8563 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8564 wxString *arg2 = 0 ;
8565 wxString result;
8566 bool temp2 = false ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 char *kwnames[] = {
8570 (char *) "self",(char *) "location", NULL
8571 };
8572
8573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8575 if (SWIG_arg_fail(1)) SWIG_fail;
8576 {
8577 arg2 = wxString_in_helper(obj1);
8578 if (arg2 == NULL) SWIG_fail;
8579 temp2 = true;
8580 }
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (arg1)->GetAnchor((wxString const &)*arg2);
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 {
8589 #if wxUSE_UNICODE
8590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8591 #else
8592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8593 #endif
8594 }
8595 {
8596 if (temp2)
8597 delete arg2;
8598 }
8599 return resultobj;
8600 fail:
8601 {
8602 if (temp2)
8603 delete arg2;
8604 }
8605 return NULL;
8606 }
8607
8608
8609 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8610 PyObject *resultobj;
8611 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8612 wxString *arg2 = 0 ;
8613 wxString result;
8614 bool temp2 = false ;
8615 PyObject * obj0 = 0 ;
8616 PyObject * obj1 = 0 ;
8617 char *kwnames[] = {
8618 (char *) "self",(char *) "location", NULL
8619 };
8620
8621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8623 if (SWIG_arg_fail(1)) SWIG_fail;
8624 {
8625 arg2 = wxString_in_helper(obj1);
8626 if (arg2 == NULL) SWIG_fail;
8627 temp2 = true;
8628 }
8629 {
8630 PyThreadState* __tstate = wxPyBeginAllowThreads();
8631 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8632
8633 wxPyEndAllowThreads(__tstate);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 {
8637 #if wxUSE_UNICODE
8638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8639 #else
8640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8641 #endif
8642 }
8643 {
8644 if (temp2)
8645 delete arg2;
8646 }
8647 return resultobj;
8648 fail:
8649 {
8650 if (temp2)
8651 delete arg2;
8652 }
8653 return NULL;
8654 }
8655
8656
8657 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj;
8659 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8660 wxString *arg2 = 0 ;
8661 wxString result;
8662 bool temp2 = false ;
8663 PyObject * obj0 = 0 ;
8664 PyObject * obj1 = 0 ;
8665 char *kwnames[] = {
8666 (char *) "self",(char *) "location", NULL
8667 };
8668
8669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8671 if (SWIG_arg_fail(1)) SWIG_fail;
8672 {
8673 arg2 = wxString_in_helper(obj1);
8674 if (arg2 == NULL) SWIG_fail;
8675 temp2 = true;
8676 }
8677 {
8678 PyThreadState* __tstate = wxPyBeginAllowThreads();
8679 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8680
8681 wxPyEndAllowThreads(__tstate);
8682 if (PyErr_Occurred()) SWIG_fail;
8683 }
8684 {
8685 #if wxUSE_UNICODE
8686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8687 #else
8688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8689 #endif
8690 }
8691 {
8692 if (temp2)
8693 delete arg2;
8694 }
8695 return resultobj;
8696 fail:
8697 {
8698 if (temp2)
8699 delete arg2;
8700 }
8701 return NULL;
8702 }
8703
8704
8705 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8706 PyObject *obj;
8707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8708 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8709 Py_INCREF(obj);
8710 return Py_BuildValue((char *)"");
8711 }
8712 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8713 PyObject *resultobj;
8714 wxFileSystem *result;
8715 char *kwnames[] = {
8716 NULL
8717 };
8718
8719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8720 {
8721 PyThreadState* __tstate = wxPyBeginAllowThreads();
8722 result = (wxFileSystem *)new wxFileSystem();
8723
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 {
8728 resultobj = wxPyMake_wxObject(result, 1);
8729 }
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj;
8738 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8739 PyObject * obj0 = 0 ;
8740 char *kwnames[] = {
8741 (char *) "self", NULL
8742 };
8743
8744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8746 if (SWIG_arg_fail(1)) SWIG_fail;
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 delete arg1;
8750
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 Py_INCREF(Py_None); resultobj = Py_None;
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj;
8763 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8764 wxString *arg2 = 0 ;
8765 bool arg3 = (bool) false ;
8766 bool temp2 = false ;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 PyObject * obj2 = 0 ;
8770 char *kwnames[] = {
8771 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8772 };
8773
8774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8776 if (SWIG_arg_fail(1)) SWIG_fail;
8777 {
8778 arg2 = wxString_in_helper(obj1);
8779 if (arg2 == NULL) SWIG_fail;
8780 temp2 = true;
8781 }
8782 if (obj2) {
8783 {
8784 arg3 = (bool)(SWIG_As_bool(obj2));
8785 if (SWIG_arg_fail(3)) SWIG_fail;
8786 }
8787 }
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8791
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 Py_INCREF(Py_None); resultobj = Py_None;
8796 {
8797 if (temp2)
8798 delete arg2;
8799 }
8800 return resultobj;
8801 fail:
8802 {
8803 if (temp2)
8804 delete arg2;
8805 }
8806 return NULL;
8807 }
8808
8809
8810 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj;
8812 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8813 wxString result;
8814 PyObject * obj0 = 0 ;
8815 char *kwnames[] = {
8816 (char *) "self", NULL
8817 };
8818
8819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8821 if (SWIG_arg_fail(1)) SWIG_fail;
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 result = (arg1)->GetPath();
8825
8826 wxPyEndAllowThreads(__tstate);
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 {
8830 #if wxUSE_UNICODE
8831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8832 #else
8833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8834 #endif
8835 }
8836 return resultobj;
8837 fail:
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8845 wxString *arg2 = 0 ;
8846 wxFSFile *result;
8847 bool temp2 = false ;
8848 PyObject * obj0 = 0 ;
8849 PyObject * obj1 = 0 ;
8850 char *kwnames[] = {
8851 (char *) "self",(char *) "location", NULL
8852 };
8853
8854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8856 if (SWIG_arg_fail(1)) SWIG_fail;
8857 {
8858 arg2 = wxString_in_helper(obj1);
8859 if (arg2 == NULL) SWIG_fail;
8860 temp2 = true;
8861 }
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 {
8870 resultobj = wxPyMake_wxObject(result, 1);
8871 }
8872 {
8873 if (temp2)
8874 delete arg2;
8875 }
8876 return resultobj;
8877 fail:
8878 {
8879 if (temp2)
8880 delete arg2;
8881 }
8882 return NULL;
8883 }
8884
8885
8886 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj;
8888 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8889 wxString *arg2 = 0 ;
8890 int arg3 = (int) 0 ;
8891 wxString result;
8892 bool temp2 = false ;
8893 PyObject * obj0 = 0 ;
8894 PyObject * obj1 = 0 ;
8895 PyObject * obj2 = 0 ;
8896 char *kwnames[] = {
8897 (char *) "self",(char *) "spec",(char *) "flags", NULL
8898 };
8899
8900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8902 if (SWIG_arg_fail(1)) SWIG_fail;
8903 {
8904 arg2 = wxString_in_helper(obj1);
8905 if (arg2 == NULL) SWIG_fail;
8906 temp2 = true;
8907 }
8908 if (obj2) {
8909 {
8910 arg3 = (int)(SWIG_As_int(obj2));
8911 if (SWIG_arg_fail(3)) SWIG_fail;
8912 }
8913 }
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8917
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 {
8922 #if wxUSE_UNICODE
8923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8924 #else
8925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8926 #endif
8927 }
8928 {
8929 if (temp2)
8930 delete arg2;
8931 }
8932 return resultobj;
8933 fail:
8934 {
8935 if (temp2)
8936 delete arg2;
8937 }
8938 return NULL;
8939 }
8940
8941
8942 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8943 PyObject *resultobj;
8944 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8945 wxString result;
8946 PyObject * obj0 = 0 ;
8947 char *kwnames[] = {
8948 (char *) "self", NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 result = (arg1)->FindNext();
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 {
8962 #if wxUSE_UNICODE
8963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8964 #else
8965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8966 #endif
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8977 PyObject * obj0 = 0 ;
8978 char *kwnames[] = {
8979 (char *) "handler", NULL
8980 };
8981
8982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8984 if (SWIG_arg_fail(1)) SWIG_fail;
8985 {
8986 PyThreadState* __tstate = wxPyBeginAllowThreads();
8987 wxFileSystem::AddHandler(arg1);
8988
8989 wxPyEndAllowThreads(__tstate);
8990 if (PyErr_Occurred()) SWIG_fail;
8991 }
8992 Py_INCREF(Py_None); resultobj = Py_None;
8993 return resultobj;
8994 fail:
8995 return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj;
9001 char *kwnames[] = {
9002 NULL
9003 };
9004
9005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 wxFileSystem::CleanUpHandlers();
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 Py_INCREF(Py_None); resultobj = Py_None;
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9021 PyObject *resultobj;
9022 wxString *arg1 = 0 ;
9023 wxString result;
9024 bool temp1 = false ;
9025 PyObject * obj0 = 0 ;
9026 char *kwnames[] = {
9027 (char *) "filename", NULL
9028 };
9029
9030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9031 {
9032 arg1 = wxString_in_helper(obj0);
9033 if (arg1 == NULL) SWIG_fail;
9034 temp1 = true;
9035 }
9036 {
9037 PyThreadState* __tstate = wxPyBeginAllowThreads();
9038 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9039
9040 wxPyEndAllowThreads(__tstate);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 {
9044 #if wxUSE_UNICODE
9045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9046 #else
9047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9048 #endif
9049 }
9050 {
9051 if (temp1)
9052 delete arg1;
9053 }
9054 return resultobj;
9055 fail:
9056 {
9057 if (temp1)
9058 delete arg1;
9059 }
9060 return NULL;
9061 }
9062
9063
9064 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9065 PyObject *resultobj;
9066 wxString *arg1 = 0 ;
9067 wxString result;
9068 bool temp1 = false ;
9069 PyObject * obj0 = 0 ;
9070 char *kwnames[] = {
9071 (char *) "url", NULL
9072 };
9073
9074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9075 {
9076 arg1 = wxString_in_helper(obj0);
9077 if (arg1 == NULL) SWIG_fail;
9078 temp1 = true;
9079 }
9080 {
9081 PyThreadState* __tstate = wxPyBeginAllowThreads();
9082 result = FileSystem_URLToFileName((wxString const &)*arg1);
9083
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 {
9088 #if wxUSE_UNICODE
9089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9090 #else
9091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9092 #endif
9093 }
9094 {
9095 if (temp1)
9096 delete arg1;
9097 }
9098 return resultobj;
9099 fail:
9100 {
9101 if (temp1)
9102 delete arg1;
9103 }
9104 return NULL;
9105 }
9106
9107
9108 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9109 PyObject *obj;
9110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9111 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9112 Py_INCREF(obj);
9113 return Py_BuildValue((char *)"");
9114 }
9115 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj;
9117 wxInternetFSHandler *result;
9118 char *kwnames[] = {
9119 NULL
9120 };
9121
9122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9140 wxString *arg2 = 0 ;
9141 bool result;
9142 bool temp2 = false ;
9143 PyObject * obj0 = 0 ;
9144 PyObject * obj1 = 0 ;
9145 char *kwnames[] = {
9146 (char *) "self",(char *) "location", NULL
9147 };
9148
9149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9151 if (SWIG_arg_fail(1)) SWIG_fail;
9152 {
9153 arg2 = wxString_in_helper(obj1);
9154 if (arg2 == NULL) SWIG_fail;
9155 temp2 = true;
9156 }
9157 {
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9160
9161 wxPyEndAllowThreads(__tstate);
9162 if (PyErr_Occurred()) SWIG_fail;
9163 }
9164 {
9165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9166 }
9167 {
9168 if (temp2)
9169 delete arg2;
9170 }
9171 return resultobj;
9172 fail:
9173 {
9174 if (temp2)
9175 delete arg2;
9176 }
9177 return NULL;
9178 }
9179
9180
9181 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj;
9183 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9184 wxFileSystem *arg2 = 0 ;
9185 wxString *arg3 = 0 ;
9186 wxFSFile *result;
9187 bool temp3 = false ;
9188 PyObject * obj0 = 0 ;
9189 PyObject * obj1 = 0 ;
9190 PyObject * obj2 = 0 ;
9191 char *kwnames[] = {
9192 (char *) "self",(char *) "fs",(char *) "location", NULL
9193 };
9194
9195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9197 if (SWIG_arg_fail(1)) SWIG_fail;
9198 {
9199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9200 if (SWIG_arg_fail(2)) SWIG_fail;
9201 if (arg2 == NULL) {
9202 SWIG_null_ref("wxFileSystem");
9203 }
9204 if (SWIG_arg_fail(2)) SWIG_fail;
9205 }
9206 {
9207 arg3 = wxString_in_helper(obj2);
9208 if (arg3 == NULL) SWIG_fail;
9209 temp3 = true;
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9214
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 {
9219 resultobj = wxPyMake_wxObject(result, 1);
9220 }
9221 {
9222 if (temp3)
9223 delete arg3;
9224 }
9225 return resultobj;
9226 fail:
9227 {
9228 if (temp3)
9229 delete arg3;
9230 }
9231 return NULL;
9232 }
9233
9234
9235 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9236 PyObject *obj;
9237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9238 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9239 Py_INCREF(obj);
9240 return Py_BuildValue((char *)"");
9241 }
9242 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj;
9244 wxZipFSHandler *result;
9245 char *kwnames[] = {
9246 NULL
9247 };
9248
9249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9250 {
9251 PyThreadState* __tstate = wxPyBeginAllowThreads();
9252 result = (wxZipFSHandler *)new wxZipFSHandler();
9253
9254 wxPyEndAllowThreads(__tstate);
9255 if (PyErr_Occurred()) SWIG_fail;
9256 }
9257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9258 return resultobj;
9259 fail:
9260 return NULL;
9261 }
9262
9263
9264 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9265 PyObject *resultobj;
9266 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9267 wxString *arg2 = 0 ;
9268 bool result;
9269 bool temp2 = false ;
9270 PyObject * obj0 = 0 ;
9271 PyObject * obj1 = 0 ;
9272 char *kwnames[] = {
9273 (char *) "self",(char *) "location", NULL
9274 };
9275
9276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9278 if (SWIG_arg_fail(1)) SWIG_fail;
9279 {
9280 arg2 = wxString_in_helper(obj1);
9281 if (arg2 == NULL) SWIG_fail;
9282 temp2 = true;
9283 }
9284 {
9285 PyThreadState* __tstate = wxPyBeginAllowThreads();
9286 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9287
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 {
9292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9293 }
9294 {
9295 if (temp2)
9296 delete arg2;
9297 }
9298 return resultobj;
9299 fail:
9300 {
9301 if (temp2)
9302 delete arg2;
9303 }
9304 return NULL;
9305 }
9306
9307
9308 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9309 PyObject *resultobj;
9310 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9311 wxFileSystem *arg2 = 0 ;
9312 wxString *arg3 = 0 ;
9313 wxFSFile *result;
9314 bool temp3 = false ;
9315 PyObject * obj0 = 0 ;
9316 PyObject * obj1 = 0 ;
9317 PyObject * obj2 = 0 ;
9318 char *kwnames[] = {
9319 (char *) "self",(char *) "fs",(char *) "location", NULL
9320 };
9321
9322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9324 if (SWIG_arg_fail(1)) SWIG_fail;
9325 {
9326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9327 if (SWIG_arg_fail(2)) SWIG_fail;
9328 if (arg2 == NULL) {
9329 SWIG_null_ref("wxFileSystem");
9330 }
9331 if (SWIG_arg_fail(2)) SWIG_fail;
9332 }
9333 {
9334 arg3 = wxString_in_helper(obj2);
9335 if (arg3 == NULL) SWIG_fail;
9336 temp3 = true;
9337 }
9338 {
9339 PyThreadState* __tstate = wxPyBeginAllowThreads();
9340 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9341
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 {
9346 resultobj = wxPyMake_wxObject(result, 1);
9347 }
9348 {
9349 if (temp3)
9350 delete arg3;
9351 }
9352 return resultobj;
9353 fail:
9354 {
9355 if (temp3)
9356 delete arg3;
9357 }
9358 return NULL;
9359 }
9360
9361
9362 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9363 PyObject *resultobj;
9364 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9365 wxString *arg2 = 0 ;
9366 int arg3 = (int) 0 ;
9367 wxString result;
9368 bool temp2 = false ;
9369 PyObject * obj0 = 0 ;
9370 PyObject * obj1 = 0 ;
9371 PyObject * obj2 = 0 ;
9372 char *kwnames[] = {
9373 (char *) "self",(char *) "spec",(char *) "flags", NULL
9374 };
9375
9376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9378 if (SWIG_arg_fail(1)) SWIG_fail;
9379 {
9380 arg2 = wxString_in_helper(obj1);
9381 if (arg2 == NULL) SWIG_fail;
9382 temp2 = true;
9383 }
9384 if (obj2) {
9385 {
9386 arg3 = (int)(SWIG_As_int(obj2));
9387 if (SWIG_arg_fail(3)) SWIG_fail;
9388 }
9389 }
9390 {
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 {
9398 #if wxUSE_UNICODE
9399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9400 #else
9401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9402 #endif
9403 }
9404 {
9405 if (temp2)
9406 delete arg2;
9407 }
9408 return resultobj;
9409 fail:
9410 {
9411 if (temp2)
9412 delete arg2;
9413 }
9414 return NULL;
9415 }
9416
9417
9418 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9419 PyObject *resultobj;
9420 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9421 wxString result;
9422 PyObject * obj0 = 0 ;
9423 char *kwnames[] = {
9424 (char *) "self", NULL
9425 };
9426
9427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9429 if (SWIG_arg_fail(1)) SWIG_fail;
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (arg1)->FindNext();
9433
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 {
9438 #if wxUSE_UNICODE
9439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9440 #else
9441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9442 #endif
9443 }
9444 return resultobj;
9445 fail:
9446 return NULL;
9447 }
9448
9449
9450 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9451 PyObject *obj;
9452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9453 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9454 Py_INCREF(obj);
9455 return Py_BuildValue((char *)"");
9456 }
9457 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9458 PyObject *resultobj;
9459 wxString *arg1 = 0 ;
9460 wxImage *arg2 = 0 ;
9461 long arg3 ;
9462 bool temp1 = false ;
9463 PyObject * obj0 = 0 ;
9464 PyObject * obj1 = 0 ;
9465 PyObject * obj2 = 0 ;
9466 char *kwnames[] = {
9467 (char *) "filename",(char *) "image",(char *) "type", NULL
9468 };
9469
9470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9471 {
9472 arg1 = wxString_in_helper(obj0);
9473 if (arg1 == NULL) SWIG_fail;
9474 temp1 = true;
9475 }
9476 {
9477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9478 if (SWIG_arg_fail(2)) SWIG_fail;
9479 if (arg2 == NULL) {
9480 SWIG_null_ref("wxImage");
9481 }
9482 if (SWIG_arg_fail(2)) SWIG_fail;
9483 }
9484 {
9485 arg3 = (long)(SWIG_As_long(obj2));
9486 if (SWIG_arg_fail(3)) SWIG_fail;
9487 }
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9491
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 Py_INCREF(Py_None); resultobj = Py_None;
9496 {
9497 if (temp1)
9498 delete arg1;
9499 }
9500 return resultobj;
9501 fail:
9502 {
9503 if (temp1)
9504 delete arg1;
9505 }
9506 return NULL;
9507 }
9508
9509
9510 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj;
9512 wxString *arg1 = 0 ;
9513 wxBitmap *arg2 = 0 ;
9514 long arg3 ;
9515 bool temp1 = false ;
9516 PyObject * obj0 = 0 ;
9517 PyObject * obj1 = 0 ;
9518 PyObject * obj2 = 0 ;
9519 char *kwnames[] = {
9520 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9521 };
9522
9523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9524 {
9525 arg1 = wxString_in_helper(obj0);
9526 if (arg1 == NULL) SWIG_fail;
9527 temp1 = true;
9528 }
9529 {
9530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9531 if (SWIG_arg_fail(2)) SWIG_fail;
9532 if (arg2 == NULL) {
9533 SWIG_null_ref("wxBitmap");
9534 }
9535 if (SWIG_arg_fail(2)) SWIG_fail;
9536 }
9537 {
9538 arg3 = (long)(SWIG_As_long(obj2));
9539 if (SWIG_arg_fail(3)) SWIG_fail;
9540 }
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9544
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 Py_INCREF(Py_None); resultobj = Py_None;
9549 {
9550 if (temp1)
9551 delete arg1;
9552 }
9553 return resultobj;
9554 fail:
9555 {
9556 if (temp1)
9557 delete arg1;
9558 }
9559 return NULL;
9560 }
9561
9562
9563 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9564 PyObject *resultobj;
9565 wxString *arg1 = 0 ;
9566 PyObject *arg2 = (PyObject *) 0 ;
9567 bool temp1 = false ;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 char *kwnames[] = {
9571 (char *) "filename",(char *) "data", NULL
9572 };
9573
9574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9575 {
9576 arg1 = wxString_in_helper(obj0);
9577 if (arg1 == NULL) SWIG_fail;
9578 temp1 = true;
9579 }
9580 arg2 = obj1;
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9584
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 Py_INCREF(Py_None); resultobj = Py_None;
9589 {
9590 if (temp1)
9591 delete arg1;
9592 }
9593 return resultobj;
9594 fail:
9595 {
9596 if (temp1)
9597 delete arg1;
9598 }
9599 return NULL;
9600 }
9601
9602
9603 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9604 PyObject *resultobj;
9605 wxMemoryFSHandler *result;
9606 char *kwnames[] = {
9607 NULL
9608 };
9609
9610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9614
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj;
9627 wxString *arg1 = 0 ;
9628 bool temp1 = false ;
9629 PyObject * obj0 = 0 ;
9630 char *kwnames[] = {
9631 (char *) "filename", NULL
9632 };
9633
9634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9635 {
9636 arg1 = wxString_in_helper(obj0);
9637 if (arg1 == NULL) SWIG_fail;
9638 temp1 = true;
9639 }
9640 {
9641 PyThreadState* __tstate = wxPyBeginAllowThreads();
9642 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9643
9644 wxPyEndAllowThreads(__tstate);
9645 if (PyErr_Occurred()) SWIG_fail;
9646 }
9647 Py_INCREF(Py_None); resultobj = Py_None;
9648 {
9649 if (temp1)
9650 delete arg1;
9651 }
9652 return resultobj;
9653 fail:
9654 {
9655 if (temp1)
9656 delete arg1;
9657 }
9658 return NULL;
9659 }
9660
9661
9662 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9663 PyObject *resultobj;
9664 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9665 wxString *arg2 = 0 ;
9666 bool result;
9667 bool temp2 = false ;
9668 PyObject * obj0 = 0 ;
9669 PyObject * obj1 = 0 ;
9670 char *kwnames[] = {
9671 (char *) "self",(char *) "location", NULL
9672 };
9673
9674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9676 if (SWIG_arg_fail(1)) SWIG_fail;
9677 {
9678 arg2 = wxString_in_helper(obj1);
9679 if (arg2 == NULL) SWIG_fail;
9680 temp2 = true;
9681 }
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9685
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 {
9690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9691 }
9692 {
9693 if (temp2)
9694 delete arg2;
9695 }
9696 return resultobj;
9697 fail:
9698 {
9699 if (temp2)
9700 delete arg2;
9701 }
9702 return NULL;
9703 }
9704
9705
9706 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9707 PyObject *resultobj;
9708 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9709 wxFileSystem *arg2 = 0 ;
9710 wxString *arg3 = 0 ;
9711 wxFSFile *result;
9712 bool temp3 = false ;
9713 PyObject * obj0 = 0 ;
9714 PyObject * obj1 = 0 ;
9715 PyObject * obj2 = 0 ;
9716 char *kwnames[] = {
9717 (char *) "self",(char *) "fs",(char *) "location", NULL
9718 };
9719
9720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9722 if (SWIG_arg_fail(1)) SWIG_fail;
9723 {
9724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9725 if (SWIG_arg_fail(2)) SWIG_fail;
9726 if (arg2 == NULL) {
9727 SWIG_null_ref("wxFileSystem");
9728 }
9729 if (SWIG_arg_fail(2)) SWIG_fail;
9730 }
9731 {
9732 arg3 = wxString_in_helper(obj2);
9733 if (arg3 == NULL) SWIG_fail;
9734 temp3 = true;
9735 }
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9739
9740 wxPyEndAllowThreads(__tstate);
9741 if (PyErr_Occurred()) SWIG_fail;
9742 }
9743 {
9744 resultobj = wxPyMake_wxObject(result, 1);
9745 }
9746 {
9747 if (temp3)
9748 delete arg3;
9749 }
9750 return resultobj;
9751 fail:
9752 {
9753 if (temp3)
9754 delete arg3;
9755 }
9756 return NULL;
9757 }
9758
9759
9760 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9761 PyObject *resultobj;
9762 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9763 wxString *arg2 = 0 ;
9764 int arg3 = (int) 0 ;
9765 wxString result;
9766 bool temp2 = false ;
9767 PyObject * obj0 = 0 ;
9768 PyObject * obj1 = 0 ;
9769 PyObject * obj2 = 0 ;
9770 char *kwnames[] = {
9771 (char *) "self",(char *) "spec",(char *) "flags", NULL
9772 };
9773
9774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9776 if (SWIG_arg_fail(1)) SWIG_fail;
9777 {
9778 arg2 = wxString_in_helper(obj1);
9779 if (arg2 == NULL) SWIG_fail;
9780 temp2 = true;
9781 }
9782 if (obj2) {
9783 {
9784 arg3 = (int)(SWIG_As_int(obj2));
9785 if (SWIG_arg_fail(3)) SWIG_fail;
9786 }
9787 }
9788 {
9789 PyThreadState* __tstate = wxPyBeginAllowThreads();
9790 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9791
9792 wxPyEndAllowThreads(__tstate);
9793 if (PyErr_Occurred()) SWIG_fail;
9794 }
9795 {
9796 #if wxUSE_UNICODE
9797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9798 #else
9799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9800 #endif
9801 }
9802 {
9803 if (temp2)
9804 delete arg2;
9805 }
9806 return resultobj;
9807 fail:
9808 {
9809 if (temp2)
9810 delete arg2;
9811 }
9812 return NULL;
9813 }
9814
9815
9816 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj;
9818 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9819 wxString result;
9820 PyObject * obj0 = 0 ;
9821 char *kwnames[] = {
9822 (char *) "self", NULL
9823 };
9824
9825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9827 if (SWIG_arg_fail(1)) SWIG_fail;
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 result = (arg1)->FindNext();
9831
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 {
9836 #if wxUSE_UNICODE
9837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9838 #else
9839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9840 #endif
9841 }
9842 return resultobj;
9843 fail:
9844 return NULL;
9845 }
9846
9847
9848 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9849 PyObject *obj;
9850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9851 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9852 Py_INCREF(obj);
9853 return Py_BuildValue((char *)"");
9854 }
9855 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj;
9857 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9858 wxString result;
9859 PyObject * obj0 = 0 ;
9860 char *kwnames[] = {
9861 (char *) "self", NULL
9862 };
9863
9864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9866 if (SWIG_arg_fail(1)) SWIG_fail;
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 result = (arg1)->GetName();
9870
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 {
9875 #if wxUSE_UNICODE
9876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9877 #else
9878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9879 #endif
9880 }
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9888 PyObject *resultobj;
9889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9890 wxString result;
9891 PyObject * obj0 = 0 ;
9892 char *kwnames[] = {
9893 (char *) "self", NULL
9894 };
9895
9896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9898 if (SWIG_arg_fail(1)) SWIG_fail;
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 result = (arg1)->GetExtension();
9902
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 {
9907 #if wxUSE_UNICODE
9908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9909 #else
9910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9911 #endif
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9922 long result;
9923 PyObject * obj0 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (long)(arg1)->GetType();
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 resultobj = SWIG_From_long((long)(result));
9940 }
9941 return resultobj;
9942 fail:
9943 return NULL;
9944 }
9945
9946
9947 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9948 PyObject *resultobj;
9949 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9950 wxString result;
9951 PyObject * obj0 = 0 ;
9952 char *kwnames[] = {
9953 (char *) "self", NULL
9954 };
9955
9956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9958 if (SWIG_arg_fail(1)) SWIG_fail;
9959 {
9960 PyThreadState* __tstate = wxPyBeginAllowThreads();
9961 result = (arg1)->GetMimeType();
9962
9963 wxPyEndAllowThreads(__tstate);
9964 if (PyErr_Occurred()) SWIG_fail;
9965 }
9966 {
9967 #if wxUSE_UNICODE
9968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9969 #else
9970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9971 #endif
9972 }
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj;
9981 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9982 wxString *arg2 = 0 ;
9983 bool result;
9984 bool temp2 = false ;
9985 PyObject * obj0 = 0 ;
9986 PyObject * obj1 = 0 ;
9987 char *kwnames[] = {
9988 (char *) "self",(char *) "name", NULL
9989 };
9990
9991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9993 if (SWIG_arg_fail(1)) SWIG_fail;
9994 {
9995 arg2 = wxString_in_helper(obj1);
9996 if (arg2 == NULL) SWIG_fail;
9997 temp2 = true;
9998 }
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10002
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 {
10007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10008 }
10009 {
10010 if (temp2)
10011 delete arg2;
10012 }
10013 return resultobj;
10014 fail:
10015 {
10016 if (temp2)
10017 delete arg2;
10018 }
10019 return NULL;
10020 }
10021
10022
10023 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10024 PyObject *resultobj;
10025 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10026 wxString *arg2 = 0 ;
10027 bool temp2 = false ;
10028 PyObject * obj0 = 0 ;
10029 PyObject * obj1 = 0 ;
10030 char *kwnames[] = {
10031 (char *) "self",(char *) "name", NULL
10032 };
10033
10034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10036 if (SWIG_arg_fail(1)) SWIG_fail;
10037 {
10038 arg2 = wxString_in_helper(obj1);
10039 if (arg2 == NULL) SWIG_fail;
10040 temp2 = true;
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 (arg1)->SetName((wxString const &)*arg2);
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 Py_INCREF(Py_None); resultobj = Py_None;
10050 {
10051 if (temp2)
10052 delete arg2;
10053 }
10054 return resultobj;
10055 fail:
10056 {
10057 if (temp2)
10058 delete arg2;
10059 }
10060 return NULL;
10061 }
10062
10063
10064 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj;
10066 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10067 wxString *arg2 = 0 ;
10068 bool temp2 = false ;
10069 PyObject * obj0 = 0 ;
10070 PyObject * obj1 = 0 ;
10071 char *kwnames[] = {
10072 (char *) "self",(char *) "extension", NULL
10073 };
10074
10075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10077 if (SWIG_arg_fail(1)) SWIG_fail;
10078 {
10079 arg2 = wxString_in_helper(obj1);
10080 if (arg2 == NULL) SWIG_fail;
10081 temp2 = true;
10082 }
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 (arg1)->SetExtension((wxString const &)*arg2);
10086
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 Py_INCREF(Py_None); resultobj = Py_None;
10091 {
10092 if (temp2)
10093 delete arg2;
10094 }
10095 return resultobj;
10096 fail:
10097 {
10098 if (temp2)
10099 delete arg2;
10100 }
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 long arg2 ;
10109 PyObject * obj0 = 0 ;
10110 PyObject * obj1 = 0 ;
10111 char *kwnames[] = {
10112 (char *) "self",(char *) "type", NULL
10113 };
10114
10115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10117 if (SWIG_arg_fail(1)) SWIG_fail;
10118 {
10119 arg2 = (long)(SWIG_As_long(obj1));
10120 if (SWIG_arg_fail(2)) SWIG_fail;
10121 }
10122 {
10123 PyThreadState* __tstate = wxPyBeginAllowThreads();
10124 (arg1)->SetType(arg2);
10125
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 Py_INCREF(Py_None); resultobj = Py_None;
10130 return resultobj;
10131 fail:
10132 return NULL;
10133 }
10134
10135
10136 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10137 PyObject *resultobj;
10138 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10139 wxString *arg2 = 0 ;
10140 bool temp2 = false ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "self",(char *) "mimetype", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10149 if (SWIG_arg_fail(1)) SWIG_fail;
10150 {
10151 arg2 = wxString_in_helper(obj1);
10152 if (arg2 == NULL) SWIG_fail;
10153 temp2 = true;
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 (arg1)->SetMimeType((wxString const &)*arg2);
10158
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 Py_INCREF(Py_None); resultobj = Py_None;
10163 {
10164 if (temp2)
10165 delete arg2;
10166 }
10167 return resultobj;
10168 fail:
10169 {
10170 if (temp2)
10171 delete arg2;
10172 }
10173 return NULL;
10174 }
10175
10176
10177 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10178 PyObject *obj;
10179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10180 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10181 Py_INCREF(obj);
10182 return Py_BuildValue((char *)"");
10183 }
10184 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10185 PyObject *resultobj;
10186 wxImageHistogram *result;
10187 char *kwnames[] = {
10188 NULL
10189 };
10190
10191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 result = (wxImageHistogram *)new wxImageHistogram();
10195
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10200 return resultobj;
10201 fail:
10202 return NULL;
10203 }
10204
10205
10206 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj;
10208 unsigned char arg1 ;
10209 unsigned char arg2 ;
10210 unsigned char arg3 ;
10211 unsigned long result;
10212 PyObject * obj0 = 0 ;
10213 PyObject * obj1 = 0 ;
10214 PyObject * obj2 = 0 ;
10215 char *kwnames[] = {
10216 (char *) "r",(char *) "g",(char *) "b", NULL
10217 };
10218
10219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10220 {
10221 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10222 if (SWIG_arg_fail(1)) SWIG_fail;
10223 }
10224 {
10225 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10226 if (SWIG_arg_fail(2)) SWIG_fail;
10227 }
10228 {
10229 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10230 if (SWIG_arg_fail(3)) SWIG_fail;
10231 }
10232 {
10233 PyThreadState* __tstate = wxPyBeginAllowThreads();
10234 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10235
10236 wxPyEndAllowThreads(__tstate);
10237 if (PyErr_Occurred()) SWIG_fail;
10238 }
10239 {
10240 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10241 }
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj;
10250 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10251 unsigned char *arg2 = (unsigned char *) 0 ;
10252 unsigned char *arg3 = (unsigned char *) 0 ;
10253 unsigned char *arg4 = (unsigned char *) 0 ;
10254 unsigned char arg5 = (unsigned char) 1 ;
10255 unsigned char arg6 = (unsigned char) 0 ;
10256 unsigned char arg7 = (unsigned char) 0 ;
10257 bool result;
10258 unsigned char temp2 ;
10259 int res2 = 0 ;
10260 unsigned char temp3 ;
10261 int res3 = 0 ;
10262 unsigned char temp4 ;
10263 int res4 = 0 ;
10264 PyObject * obj0 = 0 ;
10265 PyObject * obj1 = 0 ;
10266 PyObject * obj2 = 0 ;
10267 PyObject * obj3 = 0 ;
10268 char *kwnames[] = {
10269 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10270 };
10271
10272 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10273 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10274 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10277 if (SWIG_arg_fail(1)) SWIG_fail;
10278 if (obj1) {
10279 {
10280 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10281 if (SWIG_arg_fail(5)) SWIG_fail;
10282 }
10283 }
10284 if (obj2) {
10285 {
10286 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10287 if (SWIG_arg_fail(6)) SWIG_fail;
10288 }
10289 }
10290 if (obj3) {
10291 {
10292 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10293 if (SWIG_arg_fail(7)) SWIG_fail;
10294 }
10295 }
10296 {
10297 PyThreadState* __tstate = wxPyBeginAllowThreads();
10298 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10299
10300 wxPyEndAllowThreads(__tstate);
10301 if (PyErr_Occurred()) SWIG_fail;
10302 }
10303 {
10304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10305 }
10306 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10307 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10308 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10309 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10310 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10311 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10312 return resultobj;
10313 fail:
10314 return NULL;
10315 }
10316
10317
10318 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10319 PyObject *obj;
10320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10321 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10322 Py_INCREF(obj);
10323 return Py_BuildValue((char *)"");
10324 }
10325 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj;
10327 wxString *arg1 = 0 ;
10328 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10329 int arg3 = (int) -1 ;
10330 wxImage *result;
10331 bool temp1 = false ;
10332 PyObject * obj0 = 0 ;
10333 PyObject * obj1 = 0 ;
10334 PyObject * obj2 = 0 ;
10335 char *kwnames[] = {
10336 (char *) "name",(char *) "type",(char *) "index", NULL
10337 };
10338
10339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10340 {
10341 arg1 = wxString_in_helper(obj0);
10342 if (arg1 == NULL) SWIG_fail;
10343 temp1 = true;
10344 }
10345 if (obj1) {
10346 {
10347 arg2 = (long)(SWIG_As_long(obj1));
10348 if (SWIG_arg_fail(2)) SWIG_fail;
10349 }
10350 }
10351 if (obj2) {
10352 {
10353 arg3 = (int)(SWIG_As_int(obj2));
10354 if (SWIG_arg_fail(3)) SWIG_fail;
10355 }
10356 }
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10360
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10365 {
10366 if (temp1)
10367 delete arg1;
10368 }
10369 return resultobj;
10370 fail:
10371 {
10372 if (temp1)
10373 delete arg1;
10374 }
10375 return NULL;
10376 }
10377
10378
10379 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10380 PyObject *resultobj;
10381 wxImage *arg1 = (wxImage *) 0 ;
10382 PyObject * obj0 = 0 ;
10383 char *kwnames[] = {
10384 (char *) "self", NULL
10385 };
10386
10387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10389 if (SWIG_arg_fail(1)) SWIG_fail;
10390 {
10391 PyThreadState* __tstate = wxPyBeginAllowThreads();
10392 delete arg1;
10393
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 Py_INCREF(Py_None); resultobj = Py_None;
10398 return resultobj;
10399 fail:
10400 return NULL;
10401 }
10402
10403
10404 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj;
10406 wxString *arg1 = 0 ;
10407 wxString *arg2 = 0 ;
10408 int arg3 = (int) -1 ;
10409 wxImage *result;
10410 bool temp1 = false ;
10411 bool temp2 = false ;
10412 PyObject * obj0 = 0 ;
10413 PyObject * obj1 = 0 ;
10414 PyObject * obj2 = 0 ;
10415 char *kwnames[] = {
10416 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10417 };
10418
10419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10420 {
10421 arg1 = wxString_in_helper(obj0);
10422 if (arg1 == NULL) SWIG_fail;
10423 temp1 = true;
10424 }
10425 {
10426 arg2 = wxString_in_helper(obj1);
10427 if (arg2 == NULL) SWIG_fail;
10428 temp2 = true;
10429 }
10430 if (obj2) {
10431 {
10432 arg3 = (int)(SWIG_As_int(obj2));
10433 if (SWIG_arg_fail(3)) SWIG_fail;
10434 }
10435 }
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10439
10440 wxPyEndAllowThreads(__tstate);
10441 if (PyErr_Occurred()) SWIG_fail;
10442 }
10443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10444 {
10445 if (temp1)
10446 delete arg1;
10447 }
10448 {
10449 if (temp2)
10450 delete arg2;
10451 }
10452 return resultobj;
10453 fail:
10454 {
10455 if (temp1)
10456 delete arg1;
10457 }
10458 {
10459 if (temp2)
10460 delete arg2;
10461 }
10462 return NULL;
10463 }
10464
10465
10466 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj;
10468 wxInputStream *arg1 = 0 ;
10469 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10470 int arg3 = (int) -1 ;
10471 wxImage *result;
10472 wxPyInputStream *temp1 ;
10473 bool created1 ;
10474 PyObject * obj0 = 0 ;
10475 PyObject * obj1 = 0 ;
10476 PyObject * obj2 = 0 ;
10477 char *kwnames[] = {
10478 (char *) "stream",(char *) "type",(char *) "index", NULL
10479 };
10480
10481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10482 {
10483 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10484 arg1 = temp1->m_wxis;
10485 created1 = false;
10486 } else {
10487 PyErr_Clear(); // clear the failure of the wxPyConvert above
10488 arg1 = wxPyCBInputStream_create(obj0, false);
10489 if (arg1 == NULL) {
10490 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10491 SWIG_fail;
10492 }
10493 created1 = true;
10494 }
10495 }
10496 if (obj1) {
10497 {
10498 arg2 = (long)(SWIG_As_long(obj1));
10499 if (SWIG_arg_fail(2)) SWIG_fail;
10500 }
10501 }
10502 if (obj2) {
10503 {
10504 arg3 = (int)(SWIG_As_int(obj2));
10505 if (SWIG_arg_fail(3)) SWIG_fail;
10506 }
10507 }
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10511
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10516 {
10517 if (created1) delete arg1;
10518 }
10519 return resultobj;
10520 fail:
10521 {
10522 if (created1) delete arg1;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj;
10530 wxInputStream *arg1 = 0 ;
10531 wxString *arg2 = 0 ;
10532 int arg3 = (int) -1 ;
10533 wxImage *result;
10534 wxPyInputStream *temp1 ;
10535 bool created1 ;
10536 bool temp2 = false ;
10537 PyObject * obj0 = 0 ;
10538 PyObject * obj1 = 0 ;
10539 PyObject * obj2 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10545 {
10546 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10547 arg1 = temp1->m_wxis;
10548 created1 = false;
10549 } else {
10550 PyErr_Clear(); // clear the failure of the wxPyConvert above
10551 arg1 = wxPyCBInputStream_create(obj0, false);
10552 if (arg1 == NULL) {
10553 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10554 SWIG_fail;
10555 }
10556 created1 = true;
10557 }
10558 }
10559 {
10560 arg2 = wxString_in_helper(obj1);
10561 if (arg2 == NULL) SWIG_fail;
10562 temp2 = true;
10563 }
10564 if (obj2) {
10565 {
10566 arg3 = (int)(SWIG_As_int(obj2));
10567 if (SWIG_arg_fail(3)) SWIG_fail;
10568 }
10569 }
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10578 {
10579 if (created1) delete arg1;
10580 }
10581 {
10582 if (temp2)
10583 delete arg2;
10584 }
10585 return resultobj;
10586 fail:
10587 {
10588 if (created1) delete arg1;
10589 }
10590 {
10591 if (temp2)
10592 delete arg2;
10593 }
10594 return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj;
10600 int arg1 = (int) 0 ;
10601 int arg2 = (int) 0 ;
10602 bool arg3 = (bool) true ;
10603 wxImage *result;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 PyObject * obj2 = 0 ;
10607 char *kwnames[] = {
10608 (char *) "width",(char *) "height",(char *) "clear", NULL
10609 };
10610
10611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10612 if (obj0) {
10613 {
10614 arg1 = (int)(SWIG_As_int(obj0));
10615 if (SWIG_arg_fail(1)) SWIG_fail;
10616 }
10617 }
10618 if (obj1) {
10619 {
10620 arg2 = (int)(SWIG_As_int(obj1));
10621 if (SWIG_arg_fail(2)) SWIG_fail;
10622 }
10623 }
10624 if (obj2) {
10625 {
10626 arg3 = (bool)(SWIG_As_bool(obj2));
10627 if (SWIG_arg_fail(3)) SWIG_fail;
10628 }
10629 }
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10633
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10638 return resultobj;
10639 fail:
10640 return NULL;
10641 }
10642
10643
10644 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj;
10646 wxBitmap *arg1 = 0 ;
10647 wxImage *result;
10648 PyObject * obj0 = 0 ;
10649 char *kwnames[] = {
10650 (char *) "bitmap", NULL
10651 };
10652
10653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10654 {
10655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10656 if (SWIG_arg_fail(1)) SWIG_fail;
10657 if (arg1 == NULL) {
10658 SWIG_null_ref("wxBitmap");
10659 }
10660 if (SWIG_arg_fail(1)) SWIG_fail;
10661 }
10662 {
10663 if (!wxPyCheckForApp()) SWIG_fail;
10664 PyThreadState* __tstate = wxPyBeginAllowThreads();
10665 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10666
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10671 return resultobj;
10672 fail:
10673 return NULL;
10674 }
10675
10676
10677 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10678 PyObject *resultobj;
10679 int arg1 ;
10680 int arg2 ;
10681 unsigned char *arg3 = (unsigned char *) 0 ;
10682 wxImage *result;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 PyObject * obj2 = 0 ;
10686 char *kwnames[] = {
10687 (char *) "width",(char *) "height",(char *) "data", NULL
10688 };
10689
10690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10691 {
10692 arg1 = (int)(SWIG_As_int(obj0));
10693 if (SWIG_arg_fail(1)) SWIG_fail;
10694 }
10695 {
10696 arg2 = (int)(SWIG_As_int(obj1));
10697 if (SWIG_arg_fail(2)) SWIG_fail;
10698 }
10699 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10700 if (SWIG_arg_fail(3)) SWIG_fail;
10701 {
10702 PyThreadState* __tstate = wxPyBeginAllowThreads();
10703 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10704
10705 wxPyEndAllowThreads(__tstate);
10706 if (PyErr_Occurred()) SWIG_fail;
10707 }
10708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10709 return resultobj;
10710 fail:
10711 return NULL;
10712 }
10713
10714
10715 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10716 PyObject *resultobj;
10717 int arg1 ;
10718 int arg2 ;
10719 unsigned char *arg3 = (unsigned char *) 0 ;
10720 unsigned char *arg4 = (unsigned char *) 0 ;
10721 wxImage *result;
10722 PyObject * obj0 = 0 ;
10723 PyObject * obj1 = 0 ;
10724 PyObject * obj2 = 0 ;
10725 PyObject * obj3 = 0 ;
10726 char *kwnames[] = {
10727 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10728 };
10729
10730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10731 {
10732 arg1 = (int)(SWIG_As_int(obj0));
10733 if (SWIG_arg_fail(1)) SWIG_fail;
10734 }
10735 {
10736 arg2 = (int)(SWIG_As_int(obj1));
10737 if (SWIG_arg_fail(2)) SWIG_fail;
10738 }
10739 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10740 if (SWIG_arg_fail(3)) SWIG_fail;
10741 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10742 if (SWIG_arg_fail(4)) SWIG_fail;
10743 {
10744 PyThreadState* __tstate = wxPyBeginAllowThreads();
10745 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10746
10747 wxPyEndAllowThreads(__tstate);
10748 if (PyErr_Occurred()) SWIG_fail;
10749 }
10750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10758 PyObject *resultobj;
10759 wxImage *arg1 = (wxImage *) 0 ;
10760 int arg2 ;
10761 int arg3 ;
10762 PyObject * obj0 = 0 ;
10763 PyObject * obj1 = 0 ;
10764 PyObject * obj2 = 0 ;
10765 char *kwnames[] = {
10766 (char *) "self",(char *) "width",(char *) "height", NULL
10767 };
10768
10769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10771 if (SWIG_arg_fail(1)) SWIG_fail;
10772 {
10773 arg2 = (int)(SWIG_As_int(obj1));
10774 if (SWIG_arg_fail(2)) SWIG_fail;
10775 }
10776 {
10777 arg3 = (int)(SWIG_As_int(obj2));
10778 if (SWIG_arg_fail(3)) SWIG_fail;
10779 }
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 (arg1)->Create(arg2,arg3);
10783
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 Py_INCREF(Py_None); resultobj = Py_None;
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj;
10796 wxImage *arg1 = (wxImage *) 0 ;
10797 PyObject * obj0 = 0 ;
10798 char *kwnames[] = {
10799 (char *) "self", NULL
10800 };
10801
10802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10804 if (SWIG_arg_fail(1)) SWIG_fail;
10805 {
10806 PyThreadState* __tstate = wxPyBeginAllowThreads();
10807 (arg1)->Destroy();
10808
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 Py_INCREF(Py_None); resultobj = Py_None;
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj;
10821 wxImage *arg1 = (wxImage *) 0 ;
10822 int arg2 ;
10823 int arg3 ;
10824 SwigValueWrapper<wxImage > result;
10825 PyObject * obj0 = 0 ;
10826 PyObject * obj1 = 0 ;
10827 PyObject * obj2 = 0 ;
10828 char *kwnames[] = {
10829 (char *) "self",(char *) "width",(char *) "height", NULL
10830 };
10831
10832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10834 if (SWIG_arg_fail(1)) SWIG_fail;
10835 {
10836 arg2 = (int)(SWIG_As_int(obj1));
10837 if (SWIG_arg_fail(2)) SWIG_fail;
10838 }
10839 {
10840 arg3 = (int)(SWIG_As_int(obj2));
10841 if (SWIG_arg_fail(3)) SWIG_fail;
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (arg1)->Scale(arg2,arg3);
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 {
10851 wxImage * resultptr;
10852 resultptr = new wxImage((wxImage &)(result));
10853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10854 }
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj;
10863 wxImage *arg1 = (wxImage *) 0 ;
10864 int arg2 ;
10865 int arg3 ;
10866 SwigValueWrapper<wxImage > result;
10867 PyObject * obj0 = 0 ;
10868 PyObject * obj1 = 0 ;
10869 PyObject * obj2 = 0 ;
10870 char *kwnames[] = {
10871 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10872 };
10873
10874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10876 if (SWIG_arg_fail(1)) SWIG_fail;
10877 {
10878 arg2 = (int)(SWIG_As_int(obj1));
10879 if (SWIG_arg_fail(2)) SWIG_fail;
10880 }
10881 {
10882 arg3 = (int)(SWIG_As_int(obj2));
10883 if (SWIG_arg_fail(3)) SWIG_fail;
10884 }
10885 {
10886 PyThreadState* __tstate = wxPyBeginAllowThreads();
10887 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10888
10889 wxPyEndAllowThreads(__tstate);
10890 if (PyErr_Occurred()) SWIG_fail;
10891 }
10892 {
10893 wxImage * resultptr;
10894 resultptr = new wxImage((wxImage &)(result));
10895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10896 }
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj;
10905 wxImage *arg1 = (wxImage *) 0 ;
10906 int arg2 ;
10907 int arg3 ;
10908 wxImage *result;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 PyObject * obj2 = 0 ;
10912 char *kwnames[] = {
10913 (char *) "self",(char *) "width",(char *) "height", NULL
10914 };
10915
10916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10918 if (SWIG_arg_fail(1)) SWIG_fail;
10919 {
10920 arg2 = (int)(SWIG_As_int(obj1));
10921 if (SWIG_arg_fail(2)) SWIG_fail;
10922 }
10923 {
10924 arg3 = (int)(SWIG_As_int(obj2));
10925 if (SWIG_arg_fail(3)) SWIG_fail;
10926 }
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 {
10930 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10931 result = (wxImage *) &_result_ref;
10932 }
10933
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10938 return resultobj;
10939 fail:
10940 return NULL;
10941 }
10942
10943
10944 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
10945 PyObject *resultobj;
10946 wxImage *arg1 = (wxImage *) 0 ;
10947 wxSize *arg2 = 0 ;
10948 wxPoint *arg3 = 0 ;
10949 int arg4 = (int) -1 ;
10950 int arg5 = (int) -1 ;
10951 int arg6 = (int) -1 ;
10952 wxImage *result;
10953 wxSize temp2 ;
10954 wxPoint temp3 ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 PyObject * obj2 = 0 ;
10958 PyObject * obj3 = 0 ;
10959 PyObject * obj4 = 0 ;
10960 PyObject * obj5 = 0 ;
10961 char *kwnames[] = {
10962 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
10963 };
10964
10965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10967 if (SWIG_arg_fail(1)) SWIG_fail;
10968 {
10969 arg2 = &temp2;
10970 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10971 }
10972 {
10973 arg3 = &temp3;
10974 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10975 }
10976 if (obj3) {
10977 {
10978 arg4 = (int)(SWIG_As_int(obj3));
10979 if (SWIG_arg_fail(4)) SWIG_fail;
10980 }
10981 }
10982 if (obj4) {
10983 {
10984 arg5 = (int)(SWIG_As_int(obj4));
10985 if (SWIG_arg_fail(5)) SWIG_fail;
10986 }
10987 }
10988 if (obj5) {
10989 {
10990 arg6 = (int)(SWIG_As_int(obj5));
10991 if (SWIG_arg_fail(6)) SWIG_fail;
10992 }
10993 }
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 {
10997 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
10998 result = (wxImage *) &_result_ref;
10999 }
11000
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj;
11013 wxImage *arg1 = (wxImage *) 0 ;
11014 int arg2 ;
11015 int arg3 ;
11016 unsigned char arg4 ;
11017 unsigned char arg5 ;
11018 unsigned char arg6 ;
11019 PyObject * obj0 = 0 ;
11020 PyObject * obj1 = 0 ;
11021 PyObject * obj2 = 0 ;
11022 PyObject * obj3 = 0 ;
11023 PyObject * obj4 = 0 ;
11024 PyObject * obj5 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11031 if (SWIG_arg_fail(1)) SWIG_fail;
11032 {
11033 arg2 = (int)(SWIG_As_int(obj1));
11034 if (SWIG_arg_fail(2)) SWIG_fail;
11035 }
11036 {
11037 arg3 = (int)(SWIG_As_int(obj2));
11038 if (SWIG_arg_fail(3)) SWIG_fail;
11039 }
11040 {
11041 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11042 if (SWIG_arg_fail(4)) SWIG_fail;
11043 }
11044 {
11045 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11046 if (SWIG_arg_fail(5)) SWIG_fail;
11047 }
11048 {
11049 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11050 if (SWIG_arg_fail(6)) SWIG_fail;
11051 }
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 Py_INCREF(Py_None); resultobj = Py_None;
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj;
11068 wxImage *arg1 = (wxImage *) 0 ;
11069 wxRect *arg2 = 0 ;
11070 unsigned char arg3 ;
11071 unsigned char arg4 ;
11072 unsigned char arg5 ;
11073 wxRect temp2 ;
11074 PyObject * obj0 = 0 ;
11075 PyObject * obj1 = 0 ;
11076 PyObject * obj2 = 0 ;
11077 PyObject * obj3 = 0 ;
11078 PyObject * obj4 = 0 ;
11079 char *kwnames[] = {
11080 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11081 };
11082
11083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11085 if (SWIG_arg_fail(1)) SWIG_fail;
11086 {
11087 arg2 = &temp2;
11088 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11089 }
11090 {
11091 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11092 if (SWIG_arg_fail(3)) SWIG_fail;
11093 }
11094 {
11095 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11096 if (SWIG_arg_fail(4)) SWIG_fail;
11097 }
11098 {
11099 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11100 if (SWIG_arg_fail(5)) SWIG_fail;
11101 }
11102 {
11103 PyThreadState* __tstate = wxPyBeginAllowThreads();
11104 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11105
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 Py_INCREF(Py_None); resultobj = Py_None;
11110 return resultobj;
11111 fail:
11112 return NULL;
11113 }
11114
11115
11116 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11117 PyObject *resultobj;
11118 wxImage *arg1 = (wxImage *) 0 ;
11119 int arg2 ;
11120 int arg3 ;
11121 unsigned char result;
11122 PyObject * obj0 = 0 ;
11123 PyObject * obj1 = 0 ;
11124 PyObject * obj2 = 0 ;
11125 char *kwnames[] = {
11126 (char *) "self",(char *) "x",(char *) "y", NULL
11127 };
11128
11129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11131 if (SWIG_arg_fail(1)) SWIG_fail;
11132 {
11133 arg2 = (int)(SWIG_As_int(obj1));
11134 if (SWIG_arg_fail(2)) SWIG_fail;
11135 }
11136 {
11137 arg3 = (int)(SWIG_As_int(obj2));
11138 if (SWIG_arg_fail(3)) SWIG_fail;
11139 }
11140 {
11141 PyThreadState* __tstate = wxPyBeginAllowThreads();
11142 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11143
11144 wxPyEndAllowThreads(__tstate);
11145 if (PyErr_Occurred()) SWIG_fail;
11146 }
11147 {
11148 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11149 }
11150 return resultobj;
11151 fail:
11152 return NULL;
11153 }
11154
11155
11156 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj;
11158 wxImage *arg1 = (wxImage *) 0 ;
11159 int arg2 ;
11160 int arg3 ;
11161 unsigned char result;
11162 PyObject * obj0 = 0 ;
11163 PyObject * obj1 = 0 ;
11164 PyObject * obj2 = 0 ;
11165 char *kwnames[] = {
11166 (char *) "self",(char *) "x",(char *) "y", NULL
11167 };
11168
11169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11171 if (SWIG_arg_fail(1)) SWIG_fail;
11172 {
11173 arg2 = (int)(SWIG_As_int(obj1));
11174 if (SWIG_arg_fail(2)) SWIG_fail;
11175 }
11176 {
11177 arg3 = (int)(SWIG_As_int(obj2));
11178 if (SWIG_arg_fail(3)) SWIG_fail;
11179 }
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11183
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 {
11188 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11189 }
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11197 PyObject *resultobj;
11198 wxImage *arg1 = (wxImage *) 0 ;
11199 int arg2 ;
11200 int arg3 ;
11201 unsigned char result;
11202 PyObject * obj0 = 0 ;
11203 PyObject * obj1 = 0 ;
11204 PyObject * obj2 = 0 ;
11205 char *kwnames[] = {
11206 (char *) "self",(char *) "x",(char *) "y", NULL
11207 };
11208
11209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11211 if (SWIG_arg_fail(1)) SWIG_fail;
11212 {
11213 arg2 = (int)(SWIG_As_int(obj1));
11214 if (SWIG_arg_fail(2)) SWIG_fail;
11215 }
11216 {
11217 arg3 = (int)(SWIG_As_int(obj2));
11218 if (SWIG_arg_fail(3)) SWIG_fail;
11219 }
11220 {
11221 PyThreadState* __tstate = wxPyBeginAllowThreads();
11222 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11223
11224 wxPyEndAllowThreads(__tstate);
11225 if (PyErr_Occurred()) SWIG_fail;
11226 }
11227 {
11228 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11229 }
11230 return resultobj;
11231 fail:
11232 return NULL;
11233 }
11234
11235
11236 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11237 PyObject *resultobj;
11238 wxImage *arg1 = (wxImage *) 0 ;
11239 int arg2 ;
11240 int arg3 ;
11241 unsigned char arg4 ;
11242 PyObject * obj0 = 0 ;
11243 PyObject * obj1 = 0 ;
11244 PyObject * obj2 = 0 ;
11245 PyObject * obj3 = 0 ;
11246 char *kwnames[] = {
11247 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11248 };
11249
11250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11252 if (SWIG_arg_fail(1)) SWIG_fail;
11253 {
11254 arg2 = (int)(SWIG_As_int(obj1));
11255 if (SWIG_arg_fail(2)) SWIG_fail;
11256 }
11257 {
11258 arg3 = (int)(SWIG_As_int(obj2));
11259 if (SWIG_arg_fail(3)) SWIG_fail;
11260 }
11261 {
11262 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11263 if (SWIG_arg_fail(4)) SWIG_fail;
11264 }
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 (arg1)->SetAlpha(arg2,arg3,arg4);
11268
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 Py_INCREF(Py_None); resultobj = Py_None;
11273 return resultobj;
11274 fail:
11275 return NULL;
11276 }
11277
11278
11279 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11280 PyObject *resultobj;
11281 wxImage *arg1 = (wxImage *) 0 ;
11282 int arg2 ;
11283 int arg3 ;
11284 unsigned char result;
11285 PyObject * obj0 = 0 ;
11286 PyObject * obj1 = 0 ;
11287 PyObject * obj2 = 0 ;
11288 char *kwnames[] = {
11289 (char *) "self",(char *) "x",(char *) "y", NULL
11290 };
11291
11292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11294 if (SWIG_arg_fail(1)) SWIG_fail;
11295 {
11296 arg2 = (int)(SWIG_As_int(obj1));
11297 if (SWIG_arg_fail(2)) SWIG_fail;
11298 }
11299 {
11300 arg3 = (int)(SWIG_As_int(obj2));
11301 if (SWIG_arg_fail(3)) SWIG_fail;
11302 }
11303 {
11304 PyThreadState* __tstate = wxPyBeginAllowThreads();
11305 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11306
11307 wxPyEndAllowThreads(__tstate);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 {
11311 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11312 }
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj;
11321 wxImage *arg1 = (wxImage *) 0 ;
11322 bool result;
11323 PyObject * obj0 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "self", NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11330 if (SWIG_arg_fail(1)) SWIG_fail;
11331 {
11332 PyThreadState* __tstate = wxPyBeginAllowThreads();
11333 result = (bool)(arg1)->HasAlpha();
11334
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 {
11339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11340 }
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj;
11349 wxImage *arg1 = (wxImage *) 0 ;
11350 PyObject * obj0 = 0 ;
11351 char *kwnames[] = {
11352 (char *) "self", NULL
11353 };
11354
11355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11357 if (SWIG_arg_fail(1)) SWIG_fail;
11358 {
11359 PyThreadState* __tstate = wxPyBeginAllowThreads();
11360 (arg1)->InitAlpha();
11361
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 Py_INCREF(Py_None); resultobj = Py_None;
11366 return resultobj;
11367 fail:
11368 return NULL;
11369 }
11370
11371
11372 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj;
11374 wxImage *arg1 = (wxImage *) 0 ;
11375 byte *arg2 = (byte *) 0 ;
11376 byte *arg3 = (byte *) 0 ;
11377 byte *arg4 = (byte *) 0 ;
11378 byte arg5 = (byte) 0 ;
11379 byte arg6 = (byte) 0 ;
11380 byte arg7 = (byte) 0 ;
11381 bool result;
11382 byte temp2 ;
11383 int res2 = 0 ;
11384 byte temp3 ;
11385 int res3 = 0 ;
11386 byte temp4 ;
11387 int res4 = 0 ;
11388 PyObject * obj0 = 0 ;
11389 PyObject * obj1 = 0 ;
11390 PyObject * obj2 = 0 ;
11391 PyObject * obj3 = 0 ;
11392 char *kwnames[] = {
11393 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11394 };
11395
11396 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11397 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11398 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11401 if (SWIG_arg_fail(1)) SWIG_fail;
11402 if (obj1) {
11403 {
11404 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11405 if (SWIG_arg_fail(5)) SWIG_fail;
11406 }
11407 }
11408 if (obj2) {
11409 {
11410 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11411 if (SWIG_arg_fail(6)) SWIG_fail;
11412 }
11413 }
11414 if (obj3) {
11415 {
11416 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11417 if (SWIG_arg_fail(7)) SWIG_fail;
11418 }
11419 }
11420 {
11421 PyThreadState* __tstate = wxPyBeginAllowThreads();
11422 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11423
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 {
11428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11429 }
11430 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11431 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11432 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11433 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11434 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11435 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11436 return resultobj;
11437 fail:
11438 return NULL;
11439 }
11440
11441
11442 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11443 PyObject *resultobj;
11444 wxImage *arg1 = (wxImage *) 0 ;
11445 byte arg2 = (byte) 128 ;
11446 bool result;
11447 PyObject * obj0 = 0 ;
11448 PyObject * obj1 = 0 ;
11449 char *kwnames[] = {
11450 (char *) "self",(char *) "threshold", NULL
11451 };
11452
11453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11455 if (SWIG_arg_fail(1)) SWIG_fail;
11456 if (obj1) {
11457 {
11458 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11459 if (SWIG_arg_fail(2)) SWIG_fail;
11460 }
11461 }
11462 {
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11465
11466 wxPyEndAllowThreads(__tstate);
11467 if (PyErr_Occurred()) SWIG_fail;
11468 }
11469 {
11470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11471 }
11472 return resultobj;
11473 fail:
11474 return NULL;
11475 }
11476
11477
11478 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11479 PyObject *resultobj;
11480 wxImage *arg1 = (wxImage *) 0 ;
11481 unsigned char arg2 ;
11482 unsigned char arg3 ;
11483 unsigned char arg4 ;
11484 bool result;
11485 PyObject * obj0 = 0 ;
11486 PyObject * obj1 = 0 ;
11487 PyObject * obj2 = 0 ;
11488 PyObject * obj3 = 0 ;
11489 char *kwnames[] = {
11490 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11491 };
11492
11493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 {
11497 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11498 if (SWIG_arg_fail(2)) SWIG_fail;
11499 }
11500 {
11501 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11502 if (SWIG_arg_fail(3)) SWIG_fail;
11503 }
11504 {
11505 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11506 if (SWIG_arg_fail(4)) SWIG_fail;
11507 }
11508 {
11509 PyThreadState* __tstate = wxPyBeginAllowThreads();
11510 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11511
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 {
11516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11517 }
11518 return resultobj;
11519 fail:
11520 return NULL;
11521 }
11522
11523
11524 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11525 PyObject *resultobj;
11526 wxImage *arg1 = (wxImage *) 0 ;
11527 wxImage *arg2 = 0 ;
11528 byte arg3 ;
11529 byte arg4 ;
11530 byte arg5 ;
11531 bool result;
11532 PyObject * obj0 = 0 ;
11533 PyObject * obj1 = 0 ;
11534 PyObject * obj2 = 0 ;
11535 PyObject * obj3 = 0 ;
11536 PyObject * obj4 = 0 ;
11537 char *kwnames[] = {
11538 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11539 };
11540
11541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11543 if (SWIG_arg_fail(1)) SWIG_fail;
11544 {
11545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11546 if (SWIG_arg_fail(2)) SWIG_fail;
11547 if (arg2 == NULL) {
11548 SWIG_null_ref("wxImage");
11549 }
11550 if (SWIG_arg_fail(2)) SWIG_fail;
11551 }
11552 {
11553 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11554 if (SWIG_arg_fail(3)) SWIG_fail;
11555 }
11556 {
11557 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11558 if (SWIG_arg_fail(4)) SWIG_fail;
11559 }
11560 {
11561 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11562 if (SWIG_arg_fail(5)) SWIG_fail;
11563 }
11564 {
11565 PyThreadState* __tstate = wxPyBeginAllowThreads();
11566 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11567
11568 wxPyEndAllowThreads(__tstate);
11569 if (PyErr_Occurred()) SWIG_fail;
11570 }
11571 {
11572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11573 }
11574 return resultobj;
11575 fail:
11576 return NULL;
11577 }
11578
11579
11580 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11581 PyObject *resultobj;
11582 wxString *arg1 = 0 ;
11583 bool result;
11584 bool temp1 = false ;
11585 PyObject * obj0 = 0 ;
11586 char *kwnames[] = {
11587 (char *) "name", NULL
11588 };
11589
11590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11591 {
11592 arg1 = wxString_in_helper(obj0);
11593 if (arg1 == NULL) SWIG_fail;
11594 temp1 = true;
11595 }
11596 {
11597 PyThreadState* __tstate = wxPyBeginAllowThreads();
11598 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11599
11600 wxPyEndAllowThreads(__tstate);
11601 if (PyErr_Occurred()) SWIG_fail;
11602 }
11603 {
11604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11605 }
11606 {
11607 if (temp1)
11608 delete arg1;
11609 }
11610 return resultobj;
11611 fail:
11612 {
11613 if (temp1)
11614 delete arg1;
11615 }
11616 return NULL;
11617 }
11618
11619
11620 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11621 PyObject *resultobj;
11622 wxString *arg1 = 0 ;
11623 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11624 int result;
11625 bool temp1 = false ;
11626 PyObject * obj0 = 0 ;
11627 PyObject * obj1 = 0 ;
11628 char *kwnames[] = {
11629 (char *) "name",(char *) "type", NULL
11630 };
11631
11632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11633 {
11634 arg1 = wxString_in_helper(obj0);
11635 if (arg1 == NULL) SWIG_fail;
11636 temp1 = true;
11637 }
11638 if (obj1) {
11639 {
11640 arg2 = (long)(SWIG_As_long(obj1));
11641 if (SWIG_arg_fail(2)) SWIG_fail;
11642 }
11643 }
11644 {
11645 PyThreadState* __tstate = wxPyBeginAllowThreads();
11646 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11647
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 resultobj = SWIG_From_int((int)(result));
11653 }
11654 {
11655 if (temp1)
11656 delete arg1;
11657 }
11658 return resultobj;
11659 fail:
11660 {
11661 if (temp1)
11662 delete arg1;
11663 }
11664 return NULL;
11665 }
11666
11667
11668 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11669 PyObject *resultobj;
11670 wxImage *arg1 = (wxImage *) 0 ;
11671 wxString *arg2 = 0 ;
11672 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11673 int arg4 = (int) -1 ;
11674 bool result;
11675 bool temp2 = false ;
11676 PyObject * obj0 = 0 ;
11677 PyObject * obj1 = 0 ;
11678 PyObject * obj2 = 0 ;
11679 PyObject * obj3 = 0 ;
11680 char *kwnames[] = {
11681 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11682 };
11683
11684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11686 if (SWIG_arg_fail(1)) SWIG_fail;
11687 {
11688 arg2 = wxString_in_helper(obj1);
11689 if (arg2 == NULL) SWIG_fail;
11690 temp2 = true;
11691 }
11692 if (obj2) {
11693 {
11694 arg3 = (long)(SWIG_As_long(obj2));
11695 if (SWIG_arg_fail(3)) SWIG_fail;
11696 }
11697 }
11698 if (obj3) {
11699 {
11700 arg4 = (int)(SWIG_As_int(obj3));
11701 if (SWIG_arg_fail(4)) SWIG_fail;
11702 }
11703 }
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11707
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 {
11712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11713 }
11714 {
11715 if (temp2)
11716 delete arg2;
11717 }
11718 return resultobj;
11719 fail:
11720 {
11721 if (temp2)
11722 delete arg2;
11723 }
11724 return NULL;
11725 }
11726
11727
11728 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj;
11730 wxImage *arg1 = (wxImage *) 0 ;
11731 wxString *arg2 = 0 ;
11732 wxString *arg3 = 0 ;
11733 int arg4 = (int) -1 ;
11734 bool result;
11735 bool temp2 = false ;
11736 bool temp3 = false ;
11737 PyObject * obj0 = 0 ;
11738 PyObject * obj1 = 0 ;
11739 PyObject * obj2 = 0 ;
11740 PyObject * obj3 = 0 ;
11741 char *kwnames[] = {
11742 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11743 };
11744
11745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11747 if (SWIG_arg_fail(1)) SWIG_fail;
11748 {
11749 arg2 = wxString_in_helper(obj1);
11750 if (arg2 == NULL) SWIG_fail;
11751 temp2 = true;
11752 }
11753 {
11754 arg3 = wxString_in_helper(obj2);
11755 if (arg3 == NULL) SWIG_fail;
11756 temp3 = true;
11757 }
11758 if (obj3) {
11759 {
11760 arg4 = (int)(SWIG_As_int(obj3));
11761 if (SWIG_arg_fail(4)) SWIG_fail;
11762 }
11763 }
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11767
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 {
11772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11773 }
11774 {
11775 if (temp2)
11776 delete arg2;
11777 }
11778 {
11779 if (temp3)
11780 delete arg3;
11781 }
11782 return resultobj;
11783 fail:
11784 {
11785 if (temp2)
11786 delete arg2;
11787 }
11788 {
11789 if (temp3)
11790 delete arg3;
11791 }
11792 return NULL;
11793 }
11794
11795
11796 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11797 PyObject *resultobj;
11798 wxImage *arg1 = (wxImage *) 0 ;
11799 wxString *arg2 = 0 ;
11800 int arg3 ;
11801 bool result;
11802 bool temp2 = false ;
11803 PyObject * obj0 = 0 ;
11804 PyObject * obj1 = 0 ;
11805 PyObject * obj2 = 0 ;
11806 char *kwnames[] = {
11807 (char *) "self",(char *) "name",(char *) "type", NULL
11808 };
11809
11810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11812 if (SWIG_arg_fail(1)) SWIG_fail;
11813 {
11814 arg2 = wxString_in_helper(obj1);
11815 if (arg2 == NULL) SWIG_fail;
11816 temp2 = true;
11817 }
11818 {
11819 arg3 = (int)(SWIG_As_int(obj2));
11820 if (SWIG_arg_fail(3)) SWIG_fail;
11821 }
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11825
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 {
11830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11831 }
11832 {
11833 if (temp2)
11834 delete arg2;
11835 }
11836 return resultobj;
11837 fail:
11838 {
11839 if (temp2)
11840 delete arg2;
11841 }
11842 return NULL;
11843 }
11844
11845
11846 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11847 PyObject *resultobj;
11848 wxImage *arg1 = (wxImage *) 0 ;
11849 wxString *arg2 = 0 ;
11850 wxString *arg3 = 0 ;
11851 bool result;
11852 bool temp2 = false ;
11853 bool temp3 = false ;
11854 PyObject * obj0 = 0 ;
11855 PyObject * obj1 = 0 ;
11856 PyObject * obj2 = 0 ;
11857 char *kwnames[] = {
11858 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11859 };
11860
11861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11863 if (SWIG_arg_fail(1)) SWIG_fail;
11864 {
11865 arg2 = wxString_in_helper(obj1);
11866 if (arg2 == NULL) SWIG_fail;
11867 temp2 = true;
11868 }
11869 {
11870 arg3 = wxString_in_helper(obj2);
11871 if (arg3 == NULL) SWIG_fail;
11872 temp3 = true;
11873 }
11874 {
11875 PyThreadState* __tstate = wxPyBeginAllowThreads();
11876 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11877
11878 wxPyEndAllowThreads(__tstate);
11879 if (PyErr_Occurred()) SWIG_fail;
11880 }
11881 {
11882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11883 }
11884 {
11885 if (temp2)
11886 delete arg2;
11887 }
11888 {
11889 if (temp3)
11890 delete arg3;
11891 }
11892 return resultobj;
11893 fail:
11894 {
11895 if (temp2)
11896 delete arg2;
11897 }
11898 {
11899 if (temp3)
11900 delete arg3;
11901 }
11902 return NULL;
11903 }
11904
11905
11906 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj;
11908 wxInputStream *arg1 = 0 ;
11909 bool result;
11910 wxPyInputStream *temp1 ;
11911 bool created1 ;
11912 PyObject * obj0 = 0 ;
11913 char *kwnames[] = {
11914 (char *) "stream", NULL
11915 };
11916
11917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11918 {
11919 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11920 arg1 = temp1->m_wxis;
11921 created1 = false;
11922 } else {
11923 PyErr_Clear(); // clear the failure of the wxPyConvert above
11924 arg1 = wxPyCBInputStream_create(obj0, false);
11925 if (arg1 == NULL) {
11926 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11927 SWIG_fail;
11928 }
11929 created1 = true;
11930 }
11931 }
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 result = (bool)wxImage::CanRead(*arg1);
11935
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 {
11940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11941 }
11942 {
11943 if (created1) delete arg1;
11944 }
11945 return resultobj;
11946 fail:
11947 {
11948 if (created1) delete arg1;
11949 }
11950 return NULL;
11951 }
11952
11953
11954 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj;
11956 wxImage *arg1 = (wxImage *) 0 ;
11957 wxInputStream *arg2 = 0 ;
11958 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11959 int arg4 = (int) -1 ;
11960 bool result;
11961 wxPyInputStream *temp2 ;
11962 bool created2 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 PyObject * obj2 = 0 ;
11966 PyObject * obj3 = 0 ;
11967 char *kwnames[] = {
11968 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11969 };
11970
11971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11973 if (SWIG_arg_fail(1)) SWIG_fail;
11974 {
11975 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11976 arg2 = temp2->m_wxis;
11977 created2 = false;
11978 } else {
11979 PyErr_Clear(); // clear the failure of the wxPyConvert above
11980 arg2 = wxPyCBInputStream_create(obj1, false);
11981 if (arg2 == NULL) {
11982 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11983 SWIG_fail;
11984 }
11985 created2 = true;
11986 }
11987 }
11988 if (obj2) {
11989 {
11990 arg3 = (long)(SWIG_As_long(obj2));
11991 if (SWIG_arg_fail(3)) SWIG_fail;
11992 }
11993 }
11994 if (obj3) {
11995 {
11996 arg4 = (int)(SWIG_As_int(obj3));
11997 if (SWIG_arg_fail(4)) SWIG_fail;
11998 }
11999 }
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12003
12004 wxPyEndAllowThreads(__tstate);
12005 if (PyErr_Occurred()) SWIG_fail;
12006 }
12007 {
12008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12009 }
12010 {
12011 if (created2) delete arg2;
12012 }
12013 return resultobj;
12014 fail:
12015 {
12016 if (created2) delete arg2;
12017 }
12018 return NULL;
12019 }
12020
12021
12022 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj;
12024 wxImage *arg1 = (wxImage *) 0 ;
12025 wxInputStream *arg2 = 0 ;
12026 wxString *arg3 = 0 ;
12027 int arg4 = (int) -1 ;
12028 bool result;
12029 wxPyInputStream *temp2 ;
12030 bool created2 ;
12031 bool temp3 = false ;
12032 PyObject * obj0 = 0 ;
12033 PyObject * obj1 = 0 ;
12034 PyObject * obj2 = 0 ;
12035 PyObject * obj3 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12045 arg2 = temp2->m_wxis;
12046 created2 = false;
12047 } else {
12048 PyErr_Clear(); // clear the failure of the wxPyConvert above
12049 arg2 = wxPyCBInputStream_create(obj1, false);
12050 if (arg2 == NULL) {
12051 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12052 SWIG_fail;
12053 }
12054 created2 = true;
12055 }
12056 }
12057 {
12058 arg3 = wxString_in_helper(obj2);
12059 if (arg3 == NULL) SWIG_fail;
12060 temp3 = true;
12061 }
12062 if (obj3) {
12063 {
12064 arg4 = (int)(SWIG_As_int(obj3));
12065 if (SWIG_arg_fail(4)) SWIG_fail;
12066 }
12067 }
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 {
12076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12077 }
12078 {
12079 if (created2) delete arg2;
12080 }
12081 {
12082 if (temp3)
12083 delete arg3;
12084 }
12085 return resultobj;
12086 fail:
12087 {
12088 if (created2) delete arg2;
12089 }
12090 {
12091 if (temp3)
12092 delete arg3;
12093 }
12094 return NULL;
12095 }
12096
12097
12098 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12099 PyObject *resultobj;
12100 wxImage *arg1 = (wxImage *) 0 ;
12101 bool result;
12102 PyObject * obj0 = 0 ;
12103 char *kwnames[] = {
12104 (char *) "self", NULL
12105 };
12106
12107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12109 if (SWIG_arg_fail(1)) SWIG_fail;
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (bool)(arg1)->Ok();
12113
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 {
12118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12119 }
12120 return resultobj;
12121 fail:
12122 return NULL;
12123 }
12124
12125
12126 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12127 PyObject *resultobj;
12128 wxImage *arg1 = (wxImage *) 0 ;
12129 int result;
12130 PyObject * obj0 = 0 ;
12131 char *kwnames[] = {
12132 (char *) "self", NULL
12133 };
12134
12135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12137 if (SWIG_arg_fail(1)) SWIG_fail;
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 result = (int)(arg1)->GetWidth();
12141
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 {
12146 resultobj = SWIG_From_int((int)(result));
12147 }
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12155 PyObject *resultobj;
12156 wxImage *arg1 = (wxImage *) 0 ;
12157 int result;
12158 PyObject * obj0 = 0 ;
12159 char *kwnames[] = {
12160 (char *) "self", NULL
12161 };
12162
12163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12165 if (SWIG_arg_fail(1)) SWIG_fail;
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 result = (int)(arg1)->GetHeight();
12169
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 {
12174 resultobj = SWIG_From_int((int)(result));
12175 }
12176 return resultobj;
12177 fail:
12178 return NULL;
12179 }
12180
12181
12182 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12183 PyObject *resultobj;
12184 wxImage *arg1 = (wxImage *) 0 ;
12185 wxSize result;
12186 PyObject * obj0 = 0 ;
12187 char *kwnames[] = {
12188 (char *) "self", NULL
12189 };
12190
12191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12193 if (SWIG_arg_fail(1)) SWIG_fail;
12194 {
12195 PyThreadState* __tstate = wxPyBeginAllowThreads();
12196 result = wxImage_GetSize(arg1);
12197
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 {
12202 wxSize * resultptr;
12203 resultptr = new wxSize((wxSize &)(result));
12204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12205 }
12206 return resultobj;
12207 fail:
12208 return NULL;
12209 }
12210
12211
12212 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12213 PyObject *resultobj;
12214 wxImage *arg1 = (wxImage *) 0 ;
12215 wxRect *arg2 = 0 ;
12216 SwigValueWrapper<wxImage > result;
12217 wxRect temp2 ;
12218 PyObject * obj0 = 0 ;
12219 PyObject * obj1 = 0 ;
12220 char *kwnames[] = {
12221 (char *) "self",(char *) "rect", NULL
12222 };
12223
12224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12226 if (SWIG_arg_fail(1)) SWIG_fail;
12227 {
12228 arg2 = &temp2;
12229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12230 }
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12234
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 {
12239 wxImage * resultptr;
12240 resultptr = new wxImage((wxImage &)(result));
12241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12242 }
12243 return resultobj;
12244 fail:
12245 return NULL;
12246 }
12247
12248
12249 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12250 PyObject *resultobj;
12251 wxImage *arg1 = (wxImage *) 0 ;
12252 wxSize *arg2 = 0 ;
12253 wxPoint *arg3 = 0 ;
12254 int arg4 = (int) -1 ;
12255 int arg5 = (int) -1 ;
12256 int arg6 = (int) -1 ;
12257 SwigValueWrapper<wxImage > result;
12258 wxSize temp2 ;
12259 wxPoint temp3 ;
12260 PyObject * obj0 = 0 ;
12261 PyObject * obj1 = 0 ;
12262 PyObject * obj2 = 0 ;
12263 PyObject * obj3 = 0 ;
12264 PyObject * obj4 = 0 ;
12265 PyObject * obj5 = 0 ;
12266 char *kwnames[] = {
12267 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12268 };
12269
12270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12272 if (SWIG_arg_fail(1)) SWIG_fail;
12273 {
12274 arg2 = &temp2;
12275 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12276 }
12277 {
12278 arg3 = &temp3;
12279 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12280 }
12281 if (obj3) {
12282 {
12283 arg4 = (int)(SWIG_As_int(obj3));
12284 if (SWIG_arg_fail(4)) SWIG_fail;
12285 }
12286 }
12287 if (obj4) {
12288 {
12289 arg5 = (int)(SWIG_As_int(obj4));
12290 if (SWIG_arg_fail(5)) SWIG_fail;
12291 }
12292 }
12293 if (obj5) {
12294 {
12295 arg6 = (int)(SWIG_As_int(obj5));
12296 if (SWIG_arg_fail(6)) SWIG_fail;
12297 }
12298 }
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12302
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 wxImage * resultptr;
12308 resultptr = new wxImage((wxImage &)(result));
12309 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12310 }
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12318 PyObject *resultobj;
12319 wxImage *arg1 = (wxImage *) 0 ;
12320 SwigValueWrapper<wxImage > result;
12321 PyObject * obj0 = 0 ;
12322 char *kwnames[] = {
12323 (char *) "self", NULL
12324 };
12325
12326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12328 if (SWIG_arg_fail(1)) SWIG_fail;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 result = (arg1)->Copy();
12332
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 {
12337 wxImage * resultptr;
12338 resultptr = new wxImage((wxImage &)(result));
12339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12340 }
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12348 PyObject *resultobj;
12349 wxImage *arg1 = (wxImage *) 0 ;
12350 wxImage *arg2 = 0 ;
12351 int arg3 ;
12352 int arg4 ;
12353 PyObject * obj0 = 0 ;
12354 PyObject * obj1 = 0 ;
12355 PyObject * obj2 = 0 ;
12356 PyObject * obj3 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
12365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12366 if (SWIG_arg_fail(2)) SWIG_fail;
12367 if (arg2 == NULL) {
12368 SWIG_null_ref("wxImage");
12369 }
12370 if (SWIG_arg_fail(2)) SWIG_fail;
12371 }
12372 {
12373 arg3 = (int)(SWIG_As_int(obj2));
12374 if (SWIG_arg_fail(3)) SWIG_fail;
12375 }
12376 {
12377 arg4 = (int)(SWIG_As_int(obj3));
12378 if (SWIG_arg_fail(4)) SWIG_fail;
12379 }
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12383
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 Py_INCREF(Py_None); resultobj = Py_None;
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12395 PyObject *resultobj;
12396 wxImage *arg1 = (wxImage *) 0 ;
12397 PyObject *result;
12398 PyObject * obj0 = 0 ;
12399 char *kwnames[] = {
12400 (char *) "self", NULL
12401 };
12402
12403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12405 if (SWIG_arg_fail(1)) SWIG_fail;
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (PyObject *)wxImage_GetData(arg1);
12409
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 resultobj = result;
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj;
12422 wxImage *arg1 = (wxImage *) 0 ;
12423 PyObject *arg2 = (PyObject *) 0 ;
12424 PyObject * obj0 = 0 ;
12425 PyObject * obj1 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "data", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 arg2 = obj1;
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 wxImage_SetData(arg1,arg2);
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 Py_INCREF(Py_None); resultobj = Py_None;
12442 return resultobj;
12443 fail:
12444 return NULL;
12445 }
12446
12447
12448 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12449 PyObject *resultobj;
12450 wxImage *arg1 = (wxImage *) 0 ;
12451 PyObject *result;
12452 PyObject * obj0 = 0 ;
12453 char *kwnames[] = {
12454 (char *) "self", NULL
12455 };
12456
12457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12459 if (SWIG_arg_fail(1)) SWIG_fail;
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12463
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 resultobj = result;
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj;
12476 wxImage *arg1 = (wxImage *) 0 ;
12477 PyObject *arg2 = (PyObject *) 0 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 char *kwnames[] = {
12481 (char *) "self",(char *) "data", NULL
12482 };
12483
12484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12486 if (SWIG_arg_fail(1)) SWIG_fail;
12487 arg2 = obj1;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 wxImage_SetDataBuffer(arg1,arg2);
12491
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 Py_INCREF(Py_None); resultobj = Py_None;
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj;
12504 wxImage *arg1 = (wxImage *) 0 ;
12505 PyObject *result;
12506 PyObject * obj0 = 0 ;
12507 char *kwnames[] = {
12508 (char *) "self", NULL
12509 };
12510
12511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12513 if (SWIG_arg_fail(1)) SWIG_fail;
12514 {
12515 PyThreadState* __tstate = wxPyBeginAllowThreads();
12516 result = (PyObject *)wxImage_GetAlphaData(arg1);
12517
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 resultobj = result;
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj;
12530 wxImage *arg1 = (wxImage *) 0 ;
12531 PyObject *arg2 = (PyObject *) 0 ;
12532 PyObject * obj0 = 0 ;
12533 PyObject * obj1 = 0 ;
12534 char *kwnames[] = {
12535 (char *) "self",(char *) "data", NULL
12536 };
12537
12538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12540 if (SWIG_arg_fail(1)) SWIG_fail;
12541 arg2 = obj1;
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 wxImage_SetAlphaData(arg1,arg2);
12545
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 Py_INCREF(Py_None); resultobj = Py_None;
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj;
12558 wxImage *arg1 = (wxImage *) 0 ;
12559 PyObject *result;
12560 PyObject * obj0 = 0 ;
12561 char *kwnames[] = {
12562 (char *) "self", NULL
12563 };
12564
12565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12567 if (SWIG_arg_fail(1)) SWIG_fail;
12568 {
12569 PyThreadState* __tstate = wxPyBeginAllowThreads();
12570 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12571
12572 wxPyEndAllowThreads(__tstate);
12573 if (PyErr_Occurred()) SWIG_fail;
12574 }
12575 resultobj = result;
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj;
12584 wxImage *arg1 = (wxImage *) 0 ;
12585 PyObject *arg2 = (PyObject *) 0 ;
12586 PyObject * obj0 = 0 ;
12587 PyObject * obj1 = 0 ;
12588 char *kwnames[] = {
12589 (char *) "self",(char *) "data", NULL
12590 };
12591
12592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12594 if (SWIG_arg_fail(1)) SWIG_fail;
12595 arg2 = obj1;
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 wxImage_SetAlphaBuffer(arg1,arg2);
12599
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 Py_INCREF(Py_None); resultobj = Py_None;
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxImage *arg1 = (wxImage *) 0 ;
12613 unsigned char arg2 ;
12614 unsigned char arg3 ;
12615 unsigned char arg4 ;
12616 PyObject * obj0 = 0 ;
12617 PyObject * obj1 = 0 ;
12618 PyObject * obj2 = 0 ;
12619 PyObject * obj3 = 0 ;
12620 char *kwnames[] = {
12621 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12622 };
12623
12624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12626 if (SWIG_arg_fail(1)) SWIG_fail;
12627 {
12628 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12629 if (SWIG_arg_fail(2)) SWIG_fail;
12630 }
12631 {
12632 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12633 if (SWIG_arg_fail(3)) SWIG_fail;
12634 }
12635 {
12636 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12637 if (SWIG_arg_fail(4)) SWIG_fail;
12638 }
12639 {
12640 PyThreadState* __tstate = wxPyBeginAllowThreads();
12641 (arg1)->SetMaskColour(arg2,arg3,arg4);
12642
12643 wxPyEndAllowThreads(__tstate);
12644 if (PyErr_Occurred()) SWIG_fail;
12645 }
12646 Py_INCREF(Py_None); resultobj = Py_None;
12647 return resultobj;
12648 fail:
12649 return NULL;
12650 }
12651
12652
12653 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12654 PyObject *resultobj;
12655 wxImage *arg1 = (wxImage *) 0 ;
12656 unsigned char *arg2 = (unsigned char *) 0 ;
12657 unsigned char *arg3 = (unsigned char *) 0 ;
12658 unsigned char *arg4 = (unsigned char *) 0 ;
12659 unsigned char temp2 ;
12660 int res2 = 0 ;
12661 unsigned char temp3 ;
12662 int res3 = 0 ;
12663 unsigned char temp4 ;
12664 int res4 = 0 ;
12665 PyObject * obj0 = 0 ;
12666 char *kwnames[] = {
12667 (char *) "self", NULL
12668 };
12669
12670 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12671 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12672 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) 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 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12679
12680 wxPyEndAllowThreads(__tstate);
12681 if (PyErr_Occurred()) SWIG_fail;
12682 }
12683 Py_INCREF(Py_None); resultobj = Py_None;
12684 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12685 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12686 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12687 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12688 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12689 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj;
12698 wxImage *arg1 = (wxImage *) 0 ;
12699 unsigned char result;
12700 PyObject * obj0 = 0 ;
12701 char *kwnames[] = {
12702 (char *) "self", NULL
12703 };
12704
12705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12707 if (SWIG_arg_fail(1)) SWIG_fail;
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 result = (unsigned char)(arg1)->GetMaskRed();
12711
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 {
12716 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12717 }
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12725 PyObject *resultobj;
12726 wxImage *arg1 = (wxImage *) 0 ;
12727 unsigned char result;
12728 PyObject * obj0 = 0 ;
12729 char *kwnames[] = {
12730 (char *) "self", NULL
12731 };
12732
12733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12735 if (SWIG_arg_fail(1)) SWIG_fail;
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (unsigned char)(arg1)->GetMaskGreen();
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj;
12754 wxImage *arg1 = (wxImage *) 0 ;
12755 unsigned char result;
12756 PyObject * obj0 = 0 ;
12757 char *kwnames[] = {
12758 (char *) "self", NULL
12759 };
12760
12761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12763 if (SWIG_arg_fail(1)) SWIG_fail;
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 result = (unsigned char)(arg1)->GetMaskBlue();
12767
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12773 }
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12781 PyObject *resultobj;
12782 wxImage *arg1 = (wxImage *) 0 ;
12783 bool arg2 = (bool) true ;
12784 PyObject * obj0 = 0 ;
12785 PyObject * obj1 = 0 ;
12786 char *kwnames[] = {
12787 (char *) "self",(char *) "mask", NULL
12788 };
12789
12790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12792 if (SWIG_arg_fail(1)) SWIG_fail;
12793 if (obj1) {
12794 {
12795 arg2 = (bool)(SWIG_As_bool(obj1));
12796 if (SWIG_arg_fail(2)) SWIG_fail;
12797 }
12798 }
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 (arg1)->SetMask(arg2);
12802
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 Py_INCREF(Py_None); resultobj = Py_None;
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj;
12815 wxImage *arg1 = (wxImage *) 0 ;
12816 bool result;
12817 PyObject * obj0 = 0 ;
12818 char *kwnames[] = {
12819 (char *) "self", NULL
12820 };
12821
12822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12824 if (SWIG_arg_fail(1)) SWIG_fail;
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (bool)(arg1)->HasMask();
12828
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 {
12833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12834 }
12835 return resultobj;
12836 fail:
12837 return NULL;
12838 }
12839
12840
12841 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj;
12843 wxImage *arg1 = (wxImage *) 0 ;
12844 double arg2 ;
12845 wxPoint *arg3 = 0 ;
12846 bool arg4 = (bool) true ;
12847 wxPoint *arg5 = (wxPoint *) NULL ;
12848 SwigValueWrapper<wxImage > result;
12849 wxPoint temp3 ;
12850 PyObject * obj0 = 0 ;
12851 PyObject * obj1 = 0 ;
12852 PyObject * obj2 = 0 ;
12853 PyObject * obj3 = 0 ;
12854 PyObject * obj4 = 0 ;
12855 char *kwnames[] = {
12856 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12857 };
12858
12859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12861 if (SWIG_arg_fail(1)) SWIG_fail;
12862 {
12863 arg2 = (double)(SWIG_As_double(obj1));
12864 if (SWIG_arg_fail(2)) SWIG_fail;
12865 }
12866 {
12867 arg3 = &temp3;
12868 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12869 }
12870 if (obj3) {
12871 {
12872 arg4 = (bool)(SWIG_As_bool(obj3));
12873 if (SWIG_arg_fail(4)) SWIG_fail;
12874 }
12875 }
12876 if (obj4) {
12877 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12878 if (SWIG_arg_fail(5)) SWIG_fail;
12879 }
12880 {
12881 PyThreadState* __tstate = wxPyBeginAllowThreads();
12882 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12883
12884 wxPyEndAllowThreads(__tstate);
12885 if (PyErr_Occurred()) SWIG_fail;
12886 }
12887 {
12888 wxImage * resultptr;
12889 resultptr = new wxImage((wxImage &)(result));
12890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12891 }
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj;
12900 wxImage *arg1 = (wxImage *) 0 ;
12901 bool arg2 = (bool) true ;
12902 SwigValueWrapper<wxImage > result;
12903 PyObject * obj0 = 0 ;
12904 PyObject * obj1 = 0 ;
12905 char *kwnames[] = {
12906 (char *) "self",(char *) "clockwise", NULL
12907 };
12908
12909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12911 if (SWIG_arg_fail(1)) SWIG_fail;
12912 if (obj1) {
12913 {
12914 arg2 = (bool)(SWIG_As_bool(obj1));
12915 if (SWIG_arg_fail(2)) SWIG_fail;
12916 }
12917 }
12918 {
12919 PyThreadState* __tstate = wxPyBeginAllowThreads();
12920 result = (arg1)->Rotate90(arg2);
12921
12922 wxPyEndAllowThreads(__tstate);
12923 if (PyErr_Occurred()) SWIG_fail;
12924 }
12925 {
12926 wxImage * resultptr;
12927 resultptr = new wxImage((wxImage &)(result));
12928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12929 }
12930 return resultobj;
12931 fail:
12932 return NULL;
12933 }
12934
12935
12936 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12937 PyObject *resultobj;
12938 wxImage *arg1 = (wxImage *) 0 ;
12939 bool arg2 = (bool) true ;
12940 SwigValueWrapper<wxImage > result;
12941 PyObject * obj0 = 0 ;
12942 PyObject * obj1 = 0 ;
12943 char *kwnames[] = {
12944 (char *) "self",(char *) "horizontally", NULL
12945 };
12946
12947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12949 if (SWIG_arg_fail(1)) SWIG_fail;
12950 if (obj1) {
12951 {
12952 arg2 = (bool)(SWIG_As_bool(obj1));
12953 if (SWIG_arg_fail(2)) SWIG_fail;
12954 }
12955 }
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 result = (arg1)->Mirror(arg2);
12959
12960 wxPyEndAllowThreads(__tstate);
12961 if (PyErr_Occurred()) SWIG_fail;
12962 }
12963 {
12964 wxImage * resultptr;
12965 resultptr = new wxImage((wxImage &)(result));
12966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12967 }
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj;
12976 wxImage *arg1 = (wxImage *) 0 ;
12977 unsigned char arg2 ;
12978 unsigned char arg3 ;
12979 unsigned char arg4 ;
12980 unsigned char arg5 ;
12981 unsigned char arg6 ;
12982 unsigned char arg7 ;
12983 PyObject * obj0 = 0 ;
12984 PyObject * obj1 = 0 ;
12985 PyObject * obj2 = 0 ;
12986 PyObject * obj3 = 0 ;
12987 PyObject * obj4 = 0 ;
12988 PyObject * obj5 = 0 ;
12989 PyObject * obj6 = 0 ;
12990 char *kwnames[] = {
12991 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12992 };
12993
12994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12996 if (SWIG_arg_fail(1)) SWIG_fail;
12997 {
12998 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12999 if (SWIG_arg_fail(2)) SWIG_fail;
13000 }
13001 {
13002 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13003 if (SWIG_arg_fail(3)) SWIG_fail;
13004 }
13005 {
13006 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13007 if (SWIG_arg_fail(4)) SWIG_fail;
13008 }
13009 {
13010 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13011 if (SWIG_arg_fail(5)) SWIG_fail;
13012 }
13013 {
13014 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13015 if (SWIG_arg_fail(6)) SWIG_fail;
13016 }
13017 {
13018 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13019 if (SWIG_arg_fail(7)) SWIG_fail;
13020 }
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13024
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 Py_INCREF(Py_None); resultobj = Py_None;
13029 return resultobj;
13030 fail:
13031 return NULL;
13032 }
13033
13034
13035 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13036 PyObject *resultobj;
13037 wxImage *arg1 = (wxImage *) 0 ;
13038 unsigned char arg2 ;
13039 unsigned char arg3 ;
13040 unsigned char arg4 ;
13041 SwigValueWrapper<wxImage > result;
13042 PyObject * obj0 = 0 ;
13043 PyObject * obj1 = 0 ;
13044 PyObject * obj2 = 0 ;
13045 PyObject * obj3 = 0 ;
13046 char *kwnames[] = {
13047 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13048 };
13049
13050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13052 if (SWIG_arg_fail(1)) SWIG_fail;
13053 {
13054 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13055 if (SWIG_arg_fail(2)) SWIG_fail;
13056 }
13057 {
13058 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13059 if (SWIG_arg_fail(3)) SWIG_fail;
13060 }
13061 {
13062 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13063 if (SWIG_arg_fail(4)) SWIG_fail;
13064 }
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13068
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 {
13073 wxImage * resultptr;
13074 resultptr = new wxImage((wxImage &)(result));
13075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13076 }
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 wxString *arg2 = 0 ;
13087 wxString *arg3 = 0 ;
13088 bool temp2 = false ;
13089 bool temp3 = false ;
13090 PyObject * obj0 = 0 ;
13091 PyObject * obj1 = 0 ;
13092 PyObject * obj2 = 0 ;
13093 char *kwnames[] = {
13094 (char *) "self",(char *) "name",(char *) "value", NULL
13095 };
13096
13097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13099 if (SWIG_arg_fail(1)) SWIG_fail;
13100 {
13101 arg2 = wxString_in_helper(obj1);
13102 if (arg2 == NULL) SWIG_fail;
13103 temp2 = true;
13104 }
13105 {
13106 arg3 = wxString_in_helper(obj2);
13107 if (arg3 == NULL) SWIG_fail;
13108 temp3 = true;
13109 }
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13113
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 Py_INCREF(Py_None); resultobj = Py_None;
13118 {
13119 if (temp2)
13120 delete arg2;
13121 }
13122 {
13123 if (temp3)
13124 delete arg3;
13125 }
13126 return resultobj;
13127 fail:
13128 {
13129 if (temp2)
13130 delete arg2;
13131 }
13132 {
13133 if (temp3)
13134 delete arg3;
13135 }
13136 return NULL;
13137 }
13138
13139
13140 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13141 PyObject *resultobj;
13142 wxImage *arg1 = (wxImage *) 0 ;
13143 wxString *arg2 = 0 ;
13144 int arg3 ;
13145 bool temp2 = false ;
13146 PyObject * obj0 = 0 ;
13147 PyObject * obj1 = 0 ;
13148 PyObject * obj2 = 0 ;
13149 char *kwnames[] = {
13150 (char *) "self",(char *) "name",(char *) "value", NULL
13151 };
13152
13153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13155 if (SWIG_arg_fail(1)) SWIG_fail;
13156 {
13157 arg2 = wxString_in_helper(obj1);
13158 if (arg2 == NULL) SWIG_fail;
13159 temp2 = true;
13160 }
13161 {
13162 arg3 = (int)(SWIG_As_int(obj2));
13163 if (SWIG_arg_fail(3)) SWIG_fail;
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 (arg1)->SetOption((wxString const &)*arg2,arg3);
13168
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 Py_INCREF(Py_None); resultobj = Py_None;
13173 {
13174 if (temp2)
13175 delete arg2;
13176 }
13177 return resultobj;
13178 fail:
13179 {
13180 if (temp2)
13181 delete arg2;
13182 }
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxImage *arg1 = (wxImage *) 0 ;
13190 wxString *arg2 = 0 ;
13191 wxString result;
13192 bool temp2 = false ;
13193 PyObject * obj0 = 0 ;
13194 PyObject * obj1 = 0 ;
13195 char *kwnames[] = {
13196 (char *) "self",(char *) "name", NULL
13197 };
13198
13199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13201 if (SWIG_arg_fail(1)) SWIG_fail;
13202 {
13203 arg2 = wxString_in_helper(obj1);
13204 if (arg2 == NULL) SWIG_fail;
13205 temp2 = true;
13206 }
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 {
13215 #if wxUSE_UNICODE
13216 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13217 #else
13218 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13219 #endif
13220 }
13221 {
13222 if (temp2)
13223 delete arg2;
13224 }
13225 return resultobj;
13226 fail:
13227 {
13228 if (temp2)
13229 delete arg2;
13230 }
13231 return NULL;
13232 }
13233
13234
13235 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj;
13237 wxImage *arg1 = (wxImage *) 0 ;
13238 wxString *arg2 = 0 ;
13239 int result;
13240 bool temp2 = false ;
13241 PyObject * obj0 = 0 ;
13242 PyObject * obj1 = 0 ;
13243 char *kwnames[] = {
13244 (char *) "self",(char *) "name", NULL
13245 };
13246
13247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13249 if (SWIG_arg_fail(1)) SWIG_fail;
13250 {
13251 arg2 = wxString_in_helper(obj1);
13252 if (arg2 == NULL) SWIG_fail;
13253 temp2 = true;
13254 }
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13258
13259 wxPyEndAllowThreads(__tstate);
13260 if (PyErr_Occurred()) SWIG_fail;
13261 }
13262 {
13263 resultobj = SWIG_From_int((int)(result));
13264 }
13265 {
13266 if (temp2)
13267 delete arg2;
13268 }
13269 return resultobj;
13270 fail:
13271 {
13272 if (temp2)
13273 delete arg2;
13274 }
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj;
13281 wxImage *arg1 = (wxImage *) 0 ;
13282 wxString *arg2 = 0 ;
13283 bool result;
13284 bool temp2 = false ;
13285 PyObject * obj0 = 0 ;
13286 PyObject * obj1 = 0 ;
13287 char *kwnames[] = {
13288 (char *) "self",(char *) "name", NULL
13289 };
13290
13291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13293 if (SWIG_arg_fail(1)) SWIG_fail;
13294 {
13295 arg2 = wxString_in_helper(obj1);
13296 if (arg2 == NULL) SWIG_fail;
13297 temp2 = true;
13298 }
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13302
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 {
13307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13308 }
13309 {
13310 if (temp2)
13311 delete arg2;
13312 }
13313 return resultobj;
13314 fail:
13315 {
13316 if (temp2)
13317 delete arg2;
13318 }
13319 return NULL;
13320 }
13321
13322
13323 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13324 PyObject *resultobj;
13325 wxImage *arg1 = (wxImage *) 0 ;
13326 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13327 unsigned long result;
13328 PyObject * obj0 = 0 ;
13329 PyObject * obj1 = 0 ;
13330 char *kwnames[] = {
13331 (char *) "self",(char *) "stopafter", NULL
13332 };
13333
13334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13336 if (SWIG_arg_fail(1)) SWIG_fail;
13337 if (obj1) {
13338 {
13339 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13340 if (SWIG_arg_fail(2)) SWIG_fail;
13341 }
13342 }
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 result = (unsigned long)(arg1)->CountColours(arg2);
13346
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 {
13351 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13352 }
13353 return resultobj;
13354 fail:
13355 return NULL;
13356 }
13357
13358
13359 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13360 PyObject *resultobj;
13361 wxImage *arg1 = (wxImage *) 0 ;
13362 wxImageHistogram *arg2 = 0 ;
13363 unsigned long result;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 char *kwnames[] = {
13367 (char *) "self",(char *) "h", NULL
13368 };
13369
13370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13372 if (SWIG_arg_fail(1)) SWIG_fail;
13373 {
13374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13375 if (SWIG_arg_fail(2)) SWIG_fail;
13376 if (arg2 == NULL) {
13377 SWIG_null_ref("wxImageHistogram");
13378 }
13379 if (SWIG_arg_fail(2)) SWIG_fail;
13380 }
13381 {
13382 PyThreadState* __tstate = wxPyBeginAllowThreads();
13383 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13384
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13390 }
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13398 PyObject *resultobj;
13399 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13400 PyObject * obj0 = 0 ;
13401 char *kwnames[] = {
13402 (char *) "handler", NULL
13403 };
13404
13405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13407 if (SWIG_arg_fail(1)) SWIG_fail;
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 wxImage::AddHandler(arg1);
13411
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 Py_INCREF(Py_None); resultobj = Py_None;
13416 return resultobj;
13417 fail:
13418 return NULL;
13419 }
13420
13421
13422 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13423 PyObject *resultobj;
13424 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13425 PyObject * obj0 = 0 ;
13426 char *kwnames[] = {
13427 (char *) "handler", NULL
13428 };
13429
13430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13432 if (SWIG_arg_fail(1)) SWIG_fail;
13433 {
13434 PyThreadState* __tstate = wxPyBeginAllowThreads();
13435 wxImage::InsertHandler(arg1);
13436
13437 wxPyEndAllowThreads(__tstate);
13438 if (PyErr_Occurred()) SWIG_fail;
13439 }
13440 Py_INCREF(Py_None); resultobj = Py_None;
13441 return resultobj;
13442 fail:
13443 return NULL;
13444 }
13445
13446
13447 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13448 PyObject *resultobj;
13449 wxString *arg1 = 0 ;
13450 bool result;
13451 bool temp1 = false ;
13452 PyObject * obj0 = 0 ;
13453 char *kwnames[] = {
13454 (char *) "name", NULL
13455 };
13456
13457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13458 {
13459 arg1 = wxString_in_helper(obj0);
13460 if (arg1 == NULL) SWIG_fail;
13461 temp1 = true;
13462 }
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 {
13471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13472 }
13473 {
13474 if (temp1)
13475 delete arg1;
13476 }
13477 return resultobj;
13478 fail:
13479 {
13480 if (temp1)
13481 delete arg1;
13482 }
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxString result;
13490 char *kwnames[] = {
13491 NULL
13492 };
13493
13494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 result = wxImage::GetImageExtWildcard();
13498
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 {
13503 #if wxUSE_UNICODE
13504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13505 #else
13506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13507 #endif
13508 }
13509 return resultobj;
13510 fail:
13511 return NULL;
13512 }
13513
13514
13515 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13516 PyObject *resultobj;
13517 wxImage *arg1 = (wxImage *) 0 ;
13518 int arg2 = (int) -1 ;
13519 wxBitmap result;
13520 PyObject * obj0 = 0 ;
13521 PyObject * obj1 = 0 ;
13522 char *kwnames[] = {
13523 (char *) "self",(char *) "depth", NULL
13524 };
13525
13526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13528 if (SWIG_arg_fail(1)) SWIG_fail;
13529 if (obj1) {
13530 {
13531 arg2 = (int)(SWIG_As_int(obj1));
13532 if (SWIG_arg_fail(2)) SWIG_fail;
13533 }
13534 }
13535 {
13536 if (!wxPyCheckForApp()) SWIG_fail;
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = wxImage_ConvertToBitmap(arg1,arg2);
13539
13540 wxPyEndAllowThreads(__tstate);
13541 if (PyErr_Occurred()) SWIG_fail;
13542 }
13543 {
13544 wxBitmap * resultptr;
13545 resultptr = new wxBitmap((wxBitmap &)(result));
13546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13547 }
13548 return resultobj;
13549 fail:
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxImage *arg1 = (wxImage *) 0 ;
13557 unsigned char arg2 ;
13558 unsigned char arg3 ;
13559 unsigned char arg4 ;
13560 wxBitmap result;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 PyObject * obj2 = 0 ;
13564 PyObject * obj3 = 0 ;
13565 char *kwnames[] = {
13566 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13567 };
13568
13569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13571 if (SWIG_arg_fail(1)) SWIG_fail;
13572 {
13573 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13574 if (SWIG_arg_fail(2)) SWIG_fail;
13575 }
13576 {
13577 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13578 if (SWIG_arg_fail(3)) SWIG_fail;
13579 }
13580 {
13581 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13582 if (SWIG_arg_fail(4)) SWIG_fail;
13583 }
13584 {
13585 if (!wxPyCheckForApp()) SWIG_fail;
13586 PyThreadState* __tstate = wxPyBeginAllowThreads();
13587 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13588
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 {
13593 wxBitmap * resultptr;
13594 resultptr = new wxBitmap((wxBitmap &)(result));
13595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13596 }
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13604 PyObject *obj;
13605 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13606 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13607 Py_INCREF(obj);
13608 return Py_BuildValue((char *)"");
13609 }
13610 static int _wrap_NullImage_set(PyObject *) {
13611 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13612 return 1;
13613 }
13614
13615
13616 static PyObject *_wrap_NullImage_get(void) {
13617 PyObject *pyobj;
13618
13619 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13620 return pyobj;
13621 }
13622
13623
13624 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13625 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13626 return 1;
13627 }
13628
13629
13630 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13631 PyObject *pyobj;
13632
13633 {
13634 #if wxUSE_UNICODE
13635 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13636 #else
13637 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13638 #endif
13639 }
13640 return pyobj;
13641 }
13642
13643
13644 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13645 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13646 return 1;
13647 }
13648
13649
13650 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13651 PyObject *pyobj;
13652
13653 {
13654 #if wxUSE_UNICODE
13655 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13656 #else
13657 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13658 #endif
13659 }
13660 return pyobj;
13661 }
13662
13663
13664 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13665 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13666 return 1;
13667 }
13668
13669
13670 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13671 PyObject *pyobj;
13672
13673 {
13674 #if wxUSE_UNICODE
13675 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13676 #else
13677 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13678 #endif
13679 }
13680 return pyobj;
13681 }
13682
13683
13684 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13685 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13686 return 1;
13687 }
13688
13689
13690 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13691 PyObject *pyobj;
13692
13693 {
13694 #if wxUSE_UNICODE
13695 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13696 #else
13697 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13698 #endif
13699 }
13700 return pyobj;
13701 }
13702
13703
13704 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13705 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13706 return 1;
13707 }
13708
13709
13710 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13711 PyObject *pyobj;
13712
13713 {
13714 #if wxUSE_UNICODE
13715 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13716 #else
13717 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13718 #endif
13719 }
13720 return pyobj;
13721 }
13722
13723
13724 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13725 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13726 return 1;
13727 }
13728
13729
13730 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13731 PyObject *pyobj;
13732
13733 {
13734 #if wxUSE_UNICODE
13735 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13736 #else
13737 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13738 #endif
13739 }
13740 return pyobj;
13741 }
13742
13743
13744 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13745 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13746 return 1;
13747 }
13748
13749
13750 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13751 PyObject *pyobj;
13752
13753 {
13754 #if wxUSE_UNICODE
13755 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13756 #else
13757 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13758 #endif
13759 }
13760 return pyobj;
13761 }
13762
13763
13764 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13765 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13766 return 1;
13767 }
13768
13769
13770 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13771 PyObject *pyobj;
13772
13773 {
13774 #if wxUSE_UNICODE
13775 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13776 #else
13777 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13778 #endif
13779 }
13780 return pyobj;
13781 }
13782
13783
13784 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13785 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13786 return 1;
13787 }
13788
13789
13790 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13791 PyObject *pyobj;
13792
13793 {
13794 #if wxUSE_UNICODE
13795 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13796 #else
13797 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13798 #endif
13799 }
13800 return pyobj;
13801 }
13802
13803
13804 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13805 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13806 return 1;
13807 }
13808
13809
13810 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13811 PyObject *pyobj;
13812
13813 {
13814 #if wxUSE_UNICODE
13815 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13816 #else
13817 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13818 #endif
13819 }
13820 return pyobj;
13821 }
13822
13823
13824 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13825 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13826 return 1;
13827 }
13828
13829
13830 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13831 PyObject *pyobj;
13832
13833 {
13834 #if wxUSE_UNICODE
13835 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13836 #else
13837 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13838 #endif
13839 }
13840 return pyobj;
13841 }
13842
13843
13844 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13845 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13846 return 1;
13847 }
13848
13849
13850 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13851 PyObject *pyobj;
13852
13853 {
13854 #if wxUSE_UNICODE
13855 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13856 #else
13857 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13858 #endif
13859 }
13860 return pyobj;
13861 }
13862
13863
13864 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13865 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13866 return 1;
13867 }
13868
13869
13870 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13871 PyObject *pyobj;
13872
13873 {
13874 #if wxUSE_UNICODE
13875 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13876 #else
13877 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13878 #endif
13879 }
13880 return pyobj;
13881 }
13882
13883
13884 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13885 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13886 return 1;
13887 }
13888
13889
13890 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13891 PyObject *pyobj;
13892
13893 {
13894 #if wxUSE_UNICODE
13895 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13896 #else
13897 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13898 #endif
13899 }
13900 return pyobj;
13901 }
13902
13903
13904 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13905 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13906 return 1;
13907 }
13908
13909
13910 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13911 PyObject *pyobj;
13912
13913 {
13914 #if wxUSE_UNICODE
13915 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13916 #else
13917 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13918 #endif
13919 }
13920 return pyobj;
13921 }
13922
13923
13924 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13925 PyObject *resultobj;
13926 wxBMPHandler *result;
13927 char *kwnames[] = {
13928 NULL
13929 };
13930
13931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13932 {
13933 PyThreadState* __tstate = wxPyBeginAllowThreads();
13934 result = (wxBMPHandler *)new wxBMPHandler();
13935
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13940 return resultobj;
13941 fail:
13942 return NULL;
13943 }
13944
13945
13946 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13947 PyObject *obj;
13948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13949 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13950 Py_INCREF(obj);
13951 return Py_BuildValue((char *)"");
13952 }
13953 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13954 PyObject *resultobj;
13955 wxICOHandler *result;
13956 char *kwnames[] = {
13957 NULL
13958 };
13959
13960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13961 {
13962 PyThreadState* __tstate = wxPyBeginAllowThreads();
13963 result = (wxICOHandler *)new wxICOHandler();
13964
13965 wxPyEndAllowThreads(__tstate);
13966 if (PyErr_Occurred()) SWIG_fail;
13967 }
13968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13969 return resultobj;
13970 fail:
13971 return NULL;
13972 }
13973
13974
13975 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13976 PyObject *obj;
13977 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13978 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13979 Py_INCREF(obj);
13980 return Py_BuildValue((char *)"");
13981 }
13982 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj;
13984 wxCURHandler *result;
13985 char *kwnames[] = {
13986 NULL
13987 };
13988
13989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = (wxCURHandler *)new wxCURHandler();
13993
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14005 PyObject *obj;
14006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14007 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14008 Py_INCREF(obj);
14009 return Py_BuildValue((char *)"");
14010 }
14011 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14012 PyObject *resultobj;
14013 wxANIHandler *result;
14014 char *kwnames[] = {
14015 NULL
14016 };
14017
14018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 result = (wxANIHandler *)new wxANIHandler();
14022
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14034 PyObject *obj;
14035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14036 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14037 Py_INCREF(obj);
14038 return Py_BuildValue((char *)"");
14039 }
14040 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14041 PyObject *resultobj;
14042 wxPNGHandler *result;
14043 char *kwnames[] = {
14044 NULL
14045 };
14046
14047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 result = (wxPNGHandler *)new wxPNGHandler();
14051
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14056 return resultobj;
14057 fail:
14058 return NULL;
14059 }
14060
14061
14062 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14063 PyObject *obj;
14064 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14065 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14066 Py_INCREF(obj);
14067 return Py_BuildValue((char *)"");
14068 }
14069 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14070 PyObject *resultobj;
14071 wxGIFHandler *result;
14072 char *kwnames[] = {
14073 NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 result = (wxGIFHandler *)new wxGIFHandler();
14080
14081 wxPyEndAllowThreads(__tstate);
14082 if (PyErr_Occurred()) SWIG_fail;
14083 }
14084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14085 return resultobj;
14086 fail:
14087 return NULL;
14088 }
14089
14090
14091 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14092 PyObject *obj;
14093 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14094 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14095 Py_INCREF(obj);
14096 return Py_BuildValue((char *)"");
14097 }
14098 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14099 PyObject *resultobj;
14100 wxPCXHandler *result;
14101 char *kwnames[] = {
14102 NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 result = (wxPCXHandler *)new wxPCXHandler();
14109
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14121 PyObject *obj;
14122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14123 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14124 Py_INCREF(obj);
14125 return Py_BuildValue((char *)"");
14126 }
14127 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj;
14129 wxJPEGHandler *result;
14130 char *kwnames[] = {
14131 NULL
14132 };
14133
14134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (wxJPEGHandler *)new wxJPEGHandler();
14138
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14150 PyObject *obj;
14151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14152 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14153 Py_INCREF(obj);
14154 return Py_BuildValue((char *)"");
14155 }
14156 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14157 PyObject *resultobj;
14158 wxPNMHandler *result;
14159 char *kwnames[] = {
14160 NULL
14161 };
14162
14163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 result = (wxPNMHandler *)new wxPNMHandler();
14167
14168 wxPyEndAllowThreads(__tstate);
14169 if (PyErr_Occurred()) SWIG_fail;
14170 }
14171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14172 return resultobj;
14173 fail:
14174 return NULL;
14175 }
14176
14177
14178 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14179 PyObject *obj;
14180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14181 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14182 Py_INCREF(obj);
14183 return Py_BuildValue((char *)"");
14184 }
14185 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxXPMHandler *result;
14188 char *kwnames[] = {
14189 NULL
14190 };
14191
14192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14193 {
14194 PyThreadState* __tstate = wxPyBeginAllowThreads();
14195 result = (wxXPMHandler *)new wxXPMHandler();
14196
14197 wxPyEndAllowThreads(__tstate);
14198 if (PyErr_Occurred()) SWIG_fail;
14199 }
14200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14208 PyObject *obj;
14209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14210 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14211 Py_INCREF(obj);
14212 return Py_BuildValue((char *)"");
14213 }
14214 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14215 PyObject *resultobj;
14216 wxTIFFHandler *result;
14217 char *kwnames[] = {
14218 NULL
14219 };
14220
14221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (wxTIFFHandler *)new wxTIFFHandler();
14225
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14237 PyObject *obj;
14238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14239 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14240 Py_INCREF(obj);
14241 return Py_BuildValue((char *)"");
14242 }
14243 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxImage *arg1 = 0 ;
14246 wxImage *arg2 = 0 ;
14247 int arg3 = (int) 236 ;
14248 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14249 bool result;
14250 PyObject * obj0 = 0 ;
14251 PyObject * obj1 = 0 ;
14252 PyObject * obj2 = 0 ;
14253 PyObject * obj3 = 0 ;
14254 char *kwnames[] = {
14255 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14256 };
14257
14258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14259 {
14260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(1)) SWIG_fail;
14262 if (arg1 == NULL) {
14263 SWIG_null_ref("wxImage");
14264 }
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 }
14267 {
14268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14269 if (SWIG_arg_fail(2)) SWIG_fail;
14270 if (arg2 == NULL) {
14271 SWIG_null_ref("wxImage");
14272 }
14273 if (SWIG_arg_fail(2)) SWIG_fail;
14274 }
14275 if (obj2) {
14276 {
14277 arg3 = (int)(SWIG_As_int(obj2));
14278 if (SWIG_arg_fail(3)) SWIG_fail;
14279 }
14280 }
14281 if (obj3) {
14282 {
14283 arg4 = (int)(SWIG_As_int(obj3));
14284 if (SWIG_arg_fail(4)) SWIG_fail;
14285 }
14286 }
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14290
14291 wxPyEndAllowThreads(__tstate);
14292 if (PyErr_Occurred()) SWIG_fail;
14293 }
14294 {
14295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14296 }
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14304 PyObject *obj;
14305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14306 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14307 Py_INCREF(obj);
14308 return Py_BuildValue((char *)"");
14309 }
14310 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14311 PyObject *resultobj;
14312 wxEvtHandler *result;
14313 char *kwnames[] = {
14314 NULL
14315 };
14316
14317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (wxEvtHandler *)new wxEvtHandler();
14321
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj;
14334 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14335 wxEvtHandler *result;
14336 PyObject * obj0 = 0 ;
14337 char *kwnames[] = {
14338 (char *) "self", NULL
14339 };
14340
14341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14343 if (SWIG_arg_fail(1)) SWIG_fail;
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 {
14352 resultobj = wxPyMake_wxObject(result, 0);
14353 }
14354 return resultobj;
14355 fail:
14356 return NULL;
14357 }
14358
14359
14360 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj;
14362 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14363 wxEvtHandler *result;
14364 PyObject * obj0 = 0 ;
14365 char *kwnames[] = {
14366 (char *) "self", NULL
14367 };
14368
14369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14371 if (SWIG_arg_fail(1)) SWIG_fail;
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14375
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 {
14380 resultobj = wxPyMake_wxObject(result, 0);
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj;
14390 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14391 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14392 PyObject * obj0 = 0 ;
14393 PyObject * obj1 = 0 ;
14394 char *kwnames[] = {
14395 (char *) "self",(char *) "handler", NULL
14396 };
14397
14398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14400 if (SWIG_arg_fail(1)) SWIG_fail;
14401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14402 if (SWIG_arg_fail(2)) SWIG_fail;
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 (arg1)->SetNextHandler(arg2);
14406
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 Py_INCREF(Py_None); resultobj = Py_None;
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj;
14419 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14420 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14421 PyObject * obj0 = 0 ;
14422 PyObject * obj1 = 0 ;
14423 char *kwnames[] = {
14424 (char *) "self",(char *) "handler", NULL
14425 };
14426
14427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14429 if (SWIG_arg_fail(1)) SWIG_fail;
14430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14431 if (SWIG_arg_fail(2)) SWIG_fail;
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 (arg1)->SetPreviousHandler(arg2);
14435
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 Py_INCREF(Py_None); resultobj = Py_None;
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14447 PyObject *resultobj;
14448 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14449 bool result;
14450 PyObject * obj0 = 0 ;
14451 char *kwnames[] = {
14452 (char *) "self", NULL
14453 };
14454
14455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14457 if (SWIG_arg_fail(1)) SWIG_fail;
14458 {
14459 PyThreadState* __tstate = wxPyBeginAllowThreads();
14460 result = (bool)(arg1)->GetEvtHandlerEnabled();
14461
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 {
14466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14467 }
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj;
14476 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14477 bool arg2 ;
14478 PyObject * obj0 = 0 ;
14479 PyObject * obj1 = 0 ;
14480 char *kwnames[] = {
14481 (char *) "self",(char *) "enabled", NULL
14482 };
14483
14484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(1)) SWIG_fail;
14487 {
14488 arg2 = (bool)(SWIG_As_bool(obj1));
14489 if (SWIG_arg_fail(2)) SWIG_fail;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->SetEvtHandlerEnabled(arg2);
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 Py_INCREF(Py_None); resultobj = Py_None;
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj;
14507 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14508 wxEvent *arg2 = 0 ;
14509 bool result;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 char *kwnames[] = {
14513 (char *) "self",(char *) "event", NULL
14514 };
14515
14516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 {
14520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14521 if (SWIG_arg_fail(2)) SWIG_fail;
14522 if (arg2 == NULL) {
14523 SWIG_null_ref("wxEvent");
14524 }
14525 if (SWIG_arg_fail(2)) SWIG_fail;
14526 }
14527 {
14528 PyThreadState* __tstate = wxPyBeginAllowThreads();
14529 result = (bool)(arg1)->ProcessEvent(*arg2);
14530
14531 wxPyEndAllowThreads(__tstate);
14532 if (PyErr_Occurred()) SWIG_fail;
14533 }
14534 {
14535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14536 }
14537 return resultobj;
14538 fail:
14539 return NULL;
14540 }
14541
14542
14543 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14544 PyObject *resultobj;
14545 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14546 wxEvent *arg2 = 0 ;
14547 PyObject * obj0 = 0 ;
14548 PyObject * obj1 = 0 ;
14549 char *kwnames[] = {
14550 (char *) "self",(char *) "event", NULL
14551 };
14552
14553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14555 if (SWIG_arg_fail(1)) SWIG_fail;
14556 {
14557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14558 if (SWIG_arg_fail(2)) SWIG_fail;
14559 if (arg2 == NULL) {
14560 SWIG_null_ref("wxEvent");
14561 }
14562 if (SWIG_arg_fail(2)) SWIG_fail;
14563 }
14564 {
14565 PyThreadState* __tstate = wxPyBeginAllowThreads();
14566 (arg1)->AddPendingEvent(*arg2);
14567
14568 wxPyEndAllowThreads(__tstate);
14569 if (PyErr_Occurred()) SWIG_fail;
14570 }
14571 Py_INCREF(Py_None); resultobj = Py_None;
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14579 PyObject *resultobj;
14580 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14581 PyObject * obj0 = 0 ;
14582 char *kwnames[] = {
14583 (char *) "self", NULL
14584 };
14585
14586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14588 if (SWIG_arg_fail(1)) SWIG_fail;
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 (arg1)->ProcessPendingEvents();
14592
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 Py_INCREF(Py_None); resultobj = Py_None;
14597 return resultobj;
14598 fail:
14599 return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14604 PyObject *resultobj;
14605 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14606 int arg2 ;
14607 int arg3 ;
14608 int arg4 ;
14609 PyObject *arg5 = (PyObject *) 0 ;
14610 PyObject * obj0 = 0 ;
14611 PyObject * obj1 = 0 ;
14612 PyObject * obj2 = 0 ;
14613 PyObject * obj3 = 0 ;
14614 PyObject * obj4 = 0 ;
14615 char *kwnames[] = {
14616 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14617 };
14618
14619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(1)) SWIG_fail;
14622 {
14623 arg2 = (int)(SWIG_As_int(obj1));
14624 if (SWIG_arg_fail(2)) SWIG_fail;
14625 }
14626 {
14627 arg3 = (int)(SWIG_As_int(obj2));
14628 if (SWIG_arg_fail(3)) SWIG_fail;
14629 }
14630 {
14631 arg4 = (int)(SWIG_As_int(obj3));
14632 if (SWIG_arg_fail(4)) SWIG_fail;
14633 }
14634 arg5 = obj4;
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14638
14639 wxPyEndAllowThreads(__tstate);
14640 if (PyErr_Occurred()) SWIG_fail;
14641 }
14642 Py_INCREF(Py_None); resultobj = Py_None;
14643 return resultobj;
14644 fail:
14645 return NULL;
14646 }
14647
14648
14649 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14650 PyObject *resultobj;
14651 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14652 int arg2 ;
14653 int arg3 = (int) -1 ;
14654 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14655 bool result;
14656 PyObject * obj0 = 0 ;
14657 PyObject * obj1 = 0 ;
14658 PyObject * obj2 = 0 ;
14659 PyObject * obj3 = 0 ;
14660 char *kwnames[] = {
14661 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14662 };
14663
14664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14666 if (SWIG_arg_fail(1)) SWIG_fail;
14667 {
14668 arg2 = (int)(SWIG_As_int(obj1));
14669 if (SWIG_arg_fail(2)) SWIG_fail;
14670 }
14671 if (obj2) {
14672 {
14673 arg3 = (int)(SWIG_As_int(obj2));
14674 if (SWIG_arg_fail(3)) SWIG_fail;
14675 }
14676 }
14677 if (obj3) {
14678 {
14679 arg4 = (wxEventType)(SWIG_As_int(obj3));
14680 if (SWIG_arg_fail(4)) SWIG_fail;
14681 }
14682 }
14683 {
14684 PyThreadState* __tstate = wxPyBeginAllowThreads();
14685 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14686
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 {
14691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14692 }
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj;
14701 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14702 PyObject *arg2 = (PyObject *) 0 ;
14703 bool arg3 = (bool) true ;
14704 PyObject * obj0 = 0 ;
14705 PyObject * obj1 = 0 ;
14706 PyObject * obj2 = 0 ;
14707 char *kwnames[] = {
14708 (char *) "self",(char *) "_self",(char *) "incref", NULL
14709 };
14710
14711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14713 if (SWIG_arg_fail(1)) SWIG_fail;
14714 arg2 = obj1;
14715 if (obj2) {
14716 {
14717 arg3 = (bool)(SWIG_As_bool(obj2));
14718 if (SWIG_arg_fail(3)) SWIG_fail;
14719 }
14720 }
14721 {
14722 PyThreadState* __tstate = wxPyBeginAllowThreads();
14723 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14724
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 Py_INCREF(Py_None); resultobj = Py_None;
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14736 PyObject *obj;
14737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14738 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14739 Py_INCREF(obj);
14740 return Py_BuildValue((char *)"");
14741 }
14742 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj;
14744 wxEventType result;
14745 char *kwnames[] = {
14746 NULL
14747 };
14748
14749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14750 {
14751 PyThreadState* __tstate = wxPyBeginAllowThreads();
14752 result = (wxEventType)wxNewEventType();
14753
14754 wxPyEndAllowThreads(__tstate);
14755 if (PyErr_Occurred()) SWIG_fail;
14756 }
14757 {
14758 resultobj = SWIG_From_int((int)(result));
14759 }
14760 return resultobj;
14761 fail:
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxEvent *arg1 = (wxEvent *) 0 ;
14769 PyObject * obj0 = 0 ;
14770 char *kwnames[] = {
14771 (char *) "self", NULL
14772 };
14773
14774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(1)) SWIG_fail;
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 delete arg1;
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 Py_INCREF(Py_None); resultobj = Py_None;
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxEvent *arg1 = (wxEvent *) 0 ;
14794 wxEventType arg2 ;
14795 PyObject * obj0 = 0 ;
14796 PyObject * obj1 = 0 ;
14797 char *kwnames[] = {
14798 (char *) "self",(char *) "typ", NULL
14799 };
14800
14801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14803 if (SWIG_arg_fail(1)) SWIG_fail;
14804 {
14805 arg2 = (wxEventType)(SWIG_As_int(obj1));
14806 if (SWIG_arg_fail(2)) SWIG_fail;
14807 }
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 (arg1)->SetEventType(arg2);
14811
14812 wxPyEndAllowThreads(__tstate);
14813 if (PyErr_Occurred()) SWIG_fail;
14814 }
14815 Py_INCREF(Py_None); resultobj = Py_None;
14816 return resultobj;
14817 fail:
14818 return NULL;
14819 }
14820
14821
14822 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj;
14824 wxEvent *arg1 = (wxEvent *) 0 ;
14825 wxEventType result;
14826 PyObject * obj0 = 0 ;
14827 char *kwnames[] = {
14828 (char *) "self", NULL
14829 };
14830
14831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14833 if (SWIG_arg_fail(1)) SWIG_fail;
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14837
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 resultobj = SWIG_From_int((int)(result));
14843 }
14844 return resultobj;
14845 fail:
14846 return NULL;
14847 }
14848
14849
14850 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14851 PyObject *resultobj;
14852 wxEvent *arg1 = (wxEvent *) 0 ;
14853 wxObject *result;
14854 PyObject * obj0 = 0 ;
14855 char *kwnames[] = {
14856 (char *) "self", NULL
14857 };
14858
14859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14861 if (SWIG_arg_fail(1)) SWIG_fail;
14862 {
14863 PyThreadState* __tstate = wxPyBeginAllowThreads();
14864 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14865
14866 wxPyEndAllowThreads(__tstate);
14867 if (PyErr_Occurred()) SWIG_fail;
14868 }
14869 {
14870 resultobj = wxPyMake_wxObject(result, 0);
14871 }
14872 return resultobj;
14873 fail:
14874 return NULL;
14875 }
14876
14877
14878 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj;
14880 wxEvent *arg1 = (wxEvent *) 0 ;
14881 wxObject *arg2 = (wxObject *) 0 ;
14882 PyObject * obj0 = 0 ;
14883 PyObject * obj1 = 0 ;
14884 char *kwnames[] = {
14885 (char *) "self",(char *) "obj", NULL
14886 };
14887
14888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14890 if (SWIG_arg_fail(1)) SWIG_fail;
14891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14892 if (SWIG_arg_fail(2)) SWIG_fail;
14893 {
14894 PyThreadState* __tstate = wxPyBeginAllowThreads();
14895 (arg1)->SetEventObject(arg2);
14896
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 Py_INCREF(Py_None); resultobj = Py_None;
14901 return resultobj;
14902 fail:
14903 return NULL;
14904 }
14905
14906
14907 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14908 PyObject *resultobj;
14909 wxEvent *arg1 = (wxEvent *) 0 ;
14910 long result;
14911 PyObject * obj0 = 0 ;
14912 char *kwnames[] = {
14913 (char *) "self", NULL
14914 };
14915
14916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14918 if (SWIG_arg_fail(1)) SWIG_fail;
14919 {
14920 PyThreadState* __tstate = wxPyBeginAllowThreads();
14921 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14922
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 {
14927 resultobj = SWIG_From_long((long)(result));
14928 }
14929 return resultobj;
14930 fail:
14931 return NULL;
14932 }
14933
14934
14935 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14936 PyObject *resultobj;
14937 wxEvent *arg1 = (wxEvent *) 0 ;
14938 long arg2 = (long) 0 ;
14939 PyObject * obj0 = 0 ;
14940 PyObject * obj1 = 0 ;
14941 char *kwnames[] = {
14942 (char *) "self",(char *) "ts", NULL
14943 };
14944
14945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14947 if (SWIG_arg_fail(1)) SWIG_fail;
14948 if (obj1) {
14949 {
14950 arg2 = (long)(SWIG_As_long(obj1));
14951 if (SWIG_arg_fail(2)) SWIG_fail;
14952 }
14953 }
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 (arg1)->SetTimestamp(arg2);
14957
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 Py_INCREF(Py_None); resultobj = Py_None;
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14969 PyObject *resultobj;
14970 wxEvent *arg1 = (wxEvent *) 0 ;
14971 int result;
14972 PyObject * obj0 = 0 ;
14973 char *kwnames[] = {
14974 (char *) "self", NULL
14975 };
14976
14977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14979 if (SWIG_arg_fail(1)) SWIG_fail;
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (int)((wxEvent const *)arg1)->GetId();
14983
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 {
14988 resultobj = SWIG_From_int((int)(result));
14989 }
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj;
14998 wxEvent *arg1 = (wxEvent *) 0 ;
14999 int arg2 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self",(char *) "Id", NULL
15004 };
15005
15006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 {
15010 arg2 = (int)(SWIG_As_int(obj1));
15011 if (SWIG_arg_fail(2)) SWIG_fail;
15012 }
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 (arg1)->SetId(arg2);
15016
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 Py_INCREF(Py_None); resultobj = Py_None;
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15028 PyObject *resultobj;
15029 wxEvent *arg1 = (wxEvent *) 0 ;
15030 bool result;
15031 PyObject * obj0 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 {
15047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15048 }
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15056 PyObject *resultobj;
15057 wxEvent *arg1 = (wxEvent *) 0 ;
15058 bool arg2 = (bool) true ;
15059 PyObject * obj0 = 0 ;
15060 PyObject * obj1 = 0 ;
15061 char *kwnames[] = {
15062 (char *) "self",(char *) "skip", NULL
15063 };
15064
15065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15067 if (SWIG_arg_fail(1)) SWIG_fail;
15068 if (obj1) {
15069 {
15070 arg2 = (bool)(SWIG_As_bool(obj1));
15071 if (SWIG_arg_fail(2)) SWIG_fail;
15072 }
15073 }
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 (arg1)->Skip(arg2);
15077
15078 wxPyEndAllowThreads(__tstate);
15079 if (PyErr_Occurred()) SWIG_fail;
15080 }
15081 Py_INCREF(Py_None); resultobj = Py_None;
15082 return resultobj;
15083 fail:
15084 return NULL;
15085 }
15086
15087
15088 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15089 PyObject *resultobj;
15090 wxEvent *arg1 = (wxEvent *) 0 ;
15091 bool result;
15092 PyObject * obj0 = 0 ;
15093 char *kwnames[] = {
15094 (char *) "self", NULL
15095 };
15096
15097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15099 if (SWIG_arg_fail(1)) SWIG_fail;
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15103
15104 wxPyEndAllowThreads(__tstate);
15105 if (PyErr_Occurred()) SWIG_fail;
15106 }
15107 {
15108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15109 }
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxEvent *arg1 = (wxEvent *) 0 ;
15119 bool result;
15120 PyObject * obj0 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 {
15136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15137 }
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxEvent *arg1 = (wxEvent *) 0 ;
15147 int result;
15148 PyObject * obj0 = 0 ;
15149 char *kwnames[] = {
15150 (char *) "self", NULL
15151 };
15152
15153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15155 if (SWIG_arg_fail(1)) SWIG_fail;
15156 {
15157 PyThreadState* __tstate = wxPyBeginAllowThreads();
15158 result = (int)(arg1)->StopPropagation();
15159
15160 wxPyEndAllowThreads(__tstate);
15161 if (PyErr_Occurred()) SWIG_fail;
15162 }
15163 {
15164 resultobj = SWIG_From_int((int)(result));
15165 }
15166 return resultobj;
15167 fail:
15168 return NULL;
15169 }
15170
15171
15172 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj;
15174 wxEvent *arg1 = (wxEvent *) 0 ;
15175 int arg2 ;
15176 PyObject * obj0 = 0 ;
15177 PyObject * obj1 = 0 ;
15178 char *kwnames[] = {
15179 (char *) "self",(char *) "propagationLevel", NULL
15180 };
15181
15182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15184 if (SWIG_arg_fail(1)) SWIG_fail;
15185 {
15186 arg2 = (int)(SWIG_As_int(obj1));
15187 if (SWIG_arg_fail(2)) SWIG_fail;
15188 }
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 (arg1)->ResumePropagation(arg2);
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 Py_INCREF(Py_None); resultobj = Py_None;
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj;
15205 wxEvent *arg1 = (wxEvent *) 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:Event_Clone",kwnames,&obj0)) goto fail;
15213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(1)) SWIG_fail;
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (wxEvent *)(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 * Event_swigregister(PyObject *, PyObject *args) {
15230 PyObject *obj;
15231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15232 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15233 Py_INCREF(obj);
15234 return Py_BuildValue((char *)"");
15235 }
15236 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxEvent *arg1 = 0 ;
15239 wxPropagationDisabler *result;
15240 PyObject * obj0 = 0 ;
15241 char *kwnames[] = {
15242 (char *) "event", NULL
15243 };
15244
15245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15246 {
15247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15248 if (SWIG_arg_fail(1)) SWIG_fail;
15249 if (arg1 == NULL) {
15250 SWIG_null_ref("wxEvent");
15251 }
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 }
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15257
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj;
15270 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15271 PyObject * obj0 = 0 ;
15272 char *kwnames[] = {
15273 (char *) "self", NULL
15274 };
15275
15276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15278 if (SWIG_arg_fail(1)) SWIG_fail;
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 delete arg1;
15282
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 Py_INCREF(Py_None); resultobj = Py_None;
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15294 PyObject *obj;
15295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15296 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15297 Py_INCREF(obj);
15298 return Py_BuildValue((char *)"");
15299 }
15300 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15301 PyObject *resultobj;
15302 wxEvent *arg1 = 0 ;
15303 wxPropagateOnce *result;
15304 PyObject * obj0 = 0 ;
15305 char *kwnames[] = {
15306 (char *) "event", NULL
15307 };
15308
15309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15310 {
15311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15312 if (SWIG_arg_fail(1)) SWIG_fail;
15313 if (arg1 == NULL) {
15314 SWIG_null_ref("wxEvent");
15315 }
15316 if (SWIG_arg_fail(1)) SWIG_fail;
15317 }
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15321
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15333 PyObject *resultobj;
15334 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15335 PyObject * obj0 = 0 ;
15336 char *kwnames[] = {
15337 (char *) "self", NULL
15338 };
15339
15340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15342 if (SWIG_arg_fail(1)) SWIG_fail;
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 delete arg1;
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 Py_INCREF(Py_None); resultobj = Py_None;
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15358 PyObject *obj;
15359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15360 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15361 Py_INCREF(obj);
15362 return Py_BuildValue((char *)"");
15363 }
15364 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj;
15366 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15367 int arg2 = (int) 0 ;
15368 wxCommandEvent *result;
15369 PyObject * obj0 = 0 ;
15370 PyObject * obj1 = 0 ;
15371 char *kwnames[] = {
15372 (char *) "commandType",(char *) "winid", NULL
15373 };
15374
15375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15376 if (obj0) {
15377 {
15378 arg1 = (wxEventType)(SWIG_As_int(obj0));
15379 if (SWIG_arg_fail(1)) SWIG_fail;
15380 }
15381 }
15382 if (obj1) {
15383 {
15384 arg2 = (int)(SWIG_As_int(obj1));
15385 if (SWIG_arg_fail(2)) SWIG_fail;
15386 }
15387 }
15388 {
15389 PyThreadState* __tstate = wxPyBeginAllowThreads();
15390 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15391
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15396 return resultobj;
15397 fail:
15398 return NULL;
15399 }
15400
15401
15402 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15403 PyObject *resultobj;
15404 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15405 int result;
15406 PyObject * obj0 = 0 ;
15407 char *kwnames[] = {
15408 (char *) "self", NULL
15409 };
15410
15411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(1)) SWIG_fail;
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 {
15422 resultobj = SWIG_From_int((int)(result));
15423 }
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj;
15432 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15433 wxString *arg2 = 0 ;
15434 bool temp2 = false ;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self",(char *) "s", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 arg2 = wxString_in_helper(obj1);
15446 if (arg2 == NULL) SWIG_fail;
15447 temp2 = true;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 (arg1)->SetString((wxString const &)*arg2);
15452
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 Py_INCREF(Py_None); resultobj = Py_None;
15457 {
15458 if (temp2)
15459 delete arg2;
15460 }
15461 return resultobj;
15462 fail:
15463 {
15464 if (temp2)
15465 delete arg2;
15466 }
15467 return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj;
15473 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15474 wxString result;
15475 PyObject * obj0 = 0 ;
15476 char *kwnames[] = {
15477 (char *) "self", NULL
15478 };
15479
15480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15482 if (SWIG_arg_fail(1)) SWIG_fail;
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = ((wxCommandEvent const *)arg1)->GetString();
15486
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 {
15491 #if wxUSE_UNICODE
15492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15493 #else
15494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15495 #endif
15496 }
15497 return resultobj;
15498 fail:
15499 return NULL;
15500 }
15501
15502
15503 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj;
15505 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15506 bool result;
15507 PyObject * obj0 = 0 ;
15508 char *kwnames[] = {
15509 (char *) "self", NULL
15510 };
15511
15512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15514 if (SWIG_arg_fail(1)) SWIG_fail;
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15518
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 {
15523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15524 }
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj;
15533 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15534 bool result;
15535 PyObject * obj0 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "self", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15542 if (SWIG_arg_fail(1)) SWIG_fail;
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15546
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 {
15551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15552 }
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15560 PyObject *resultobj;
15561 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15562 long arg2 ;
15563 PyObject * obj0 = 0 ;
15564 PyObject * obj1 = 0 ;
15565 char *kwnames[] = {
15566 (char *) "self",(char *) "extraLong", NULL
15567 };
15568
15569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15571 if (SWIG_arg_fail(1)) SWIG_fail;
15572 {
15573 arg2 = (long)(SWIG_As_long(obj1));
15574 if (SWIG_arg_fail(2)) SWIG_fail;
15575 }
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 (arg1)->SetExtraLong(arg2);
15579
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 Py_INCREF(Py_None); resultobj = Py_None;
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15591 PyObject *resultobj;
15592 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15593 long result;
15594 PyObject * obj0 = 0 ;
15595 char *kwnames[] = {
15596 (char *) "self", NULL
15597 };
15598
15599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15601 if (SWIG_arg_fail(1)) SWIG_fail;
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15605
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 {
15610 resultobj = SWIG_From_long((long)(result));
15611 }
15612 return resultobj;
15613 fail:
15614 return NULL;
15615 }
15616
15617
15618 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15619 PyObject *resultobj;
15620 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15621 int arg2 ;
15622 PyObject * obj0 = 0 ;
15623 PyObject * obj1 = 0 ;
15624 char *kwnames[] = {
15625 (char *) "self",(char *) "i", NULL
15626 };
15627
15628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15630 if (SWIG_arg_fail(1)) SWIG_fail;
15631 {
15632 arg2 = (int)(SWIG_As_int(obj1));
15633 if (SWIG_arg_fail(2)) SWIG_fail;
15634 }
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 (arg1)->SetInt(arg2);
15638
15639 wxPyEndAllowThreads(__tstate);
15640 if (PyErr_Occurred()) SWIG_fail;
15641 }
15642 Py_INCREF(Py_None); resultobj = Py_None;
15643 return resultobj;
15644 fail:
15645 return NULL;
15646 }
15647
15648
15649 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15650 PyObject *resultobj;
15651 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15652 long result;
15653 PyObject * obj0 = 0 ;
15654 char *kwnames[] = {
15655 (char *) "self", NULL
15656 };
15657
15658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15660 if (SWIG_arg_fail(1)) SWIG_fail;
15661 {
15662 PyThreadState* __tstate = wxPyBeginAllowThreads();
15663 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15664
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 {
15669 resultobj = SWIG_From_long((long)(result));
15670 }
15671 return resultobj;
15672 fail:
15673 return NULL;
15674 }
15675
15676
15677 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15678 PyObject *resultobj;
15679 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15680 wxEvent *result;
15681 PyObject * obj0 = 0 ;
15682 char *kwnames[] = {
15683 (char *) "self", NULL
15684 };
15685
15686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15688 if (SWIG_arg_fail(1)) SWIG_fail;
15689 {
15690 PyThreadState* __tstate = wxPyBeginAllowThreads();
15691 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15692
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15704 PyObject *obj;
15705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15706 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15707 Py_INCREF(obj);
15708 return Py_BuildValue((char *)"");
15709 }
15710 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15711 PyObject *resultobj;
15712 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15713 int arg2 = (int) 0 ;
15714 wxNotifyEvent *result;
15715 PyObject * obj0 = 0 ;
15716 PyObject * obj1 = 0 ;
15717 char *kwnames[] = {
15718 (char *) "commandType",(char *) "winid", NULL
15719 };
15720
15721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15722 if (obj0) {
15723 {
15724 arg1 = (wxEventType)(SWIG_As_int(obj0));
15725 if (SWIG_arg_fail(1)) SWIG_fail;
15726 }
15727 }
15728 if (obj1) {
15729 {
15730 arg2 = (int)(SWIG_As_int(obj1));
15731 if (SWIG_arg_fail(2)) SWIG_fail;
15732 }
15733 }
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15737
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj;
15750 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15751 PyObject * obj0 = 0 ;
15752 char *kwnames[] = {
15753 (char *) "self", NULL
15754 };
15755
15756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15758 if (SWIG_arg_fail(1)) SWIG_fail;
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 (arg1)->Veto();
15762
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 Py_INCREF(Py_None); resultobj = Py_None;
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj;
15775 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15776 PyObject * obj0 = 0 ;
15777 char *kwnames[] = {
15778 (char *) "self", NULL
15779 };
15780
15781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15783 if (SWIG_arg_fail(1)) SWIG_fail;
15784 {
15785 PyThreadState* __tstate = wxPyBeginAllowThreads();
15786 (arg1)->Allow();
15787
15788 wxPyEndAllowThreads(__tstate);
15789 if (PyErr_Occurred()) SWIG_fail;
15790 }
15791 Py_INCREF(Py_None); resultobj = Py_None;
15792 return resultobj;
15793 fail:
15794 return NULL;
15795 }
15796
15797
15798 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15799 PyObject *resultobj;
15800 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15801 bool result;
15802 PyObject * obj0 = 0 ;
15803 char *kwnames[] = {
15804 (char *) "self", NULL
15805 };
15806
15807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15809 if (SWIG_arg_fail(1)) SWIG_fail;
15810 {
15811 PyThreadState* __tstate = wxPyBeginAllowThreads();
15812 result = (bool)(arg1)->IsAllowed();
15813
15814 wxPyEndAllowThreads(__tstate);
15815 if (PyErr_Occurred()) SWIG_fail;
15816 }
15817 {
15818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15819 }
15820 return resultobj;
15821 fail:
15822 return NULL;
15823 }
15824
15825
15826 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15827 PyObject *obj;
15828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15829 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15830 Py_INCREF(obj);
15831 return Py_BuildValue((char *)"");
15832 }
15833 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15834 PyObject *resultobj;
15835 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15836 int arg2 = (int) 0 ;
15837 int arg3 = (int) 0 ;
15838 int arg4 = (int) 0 ;
15839 wxScrollEvent *result;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 PyObject * obj2 = 0 ;
15843 PyObject * obj3 = 0 ;
15844 char *kwnames[] = {
15845 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15846 };
15847
15848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15849 if (obj0) {
15850 {
15851 arg1 = (wxEventType)(SWIG_As_int(obj0));
15852 if (SWIG_arg_fail(1)) SWIG_fail;
15853 }
15854 }
15855 if (obj1) {
15856 {
15857 arg2 = (int)(SWIG_As_int(obj1));
15858 if (SWIG_arg_fail(2)) SWIG_fail;
15859 }
15860 }
15861 if (obj2) {
15862 {
15863 arg3 = (int)(SWIG_As_int(obj2));
15864 if (SWIG_arg_fail(3)) SWIG_fail;
15865 }
15866 }
15867 if (obj3) {
15868 {
15869 arg4 = (int)(SWIG_As_int(obj3));
15870 if (SWIG_arg_fail(4)) SWIG_fail;
15871 }
15872 }
15873 {
15874 PyThreadState* __tstate = wxPyBeginAllowThreads();
15875 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15876
15877 wxPyEndAllowThreads(__tstate);
15878 if (PyErr_Occurred()) SWIG_fail;
15879 }
15880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15881 return resultobj;
15882 fail:
15883 return NULL;
15884 }
15885
15886
15887 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15888 PyObject *resultobj;
15889 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15890 int result;
15891 PyObject * obj0 = 0 ;
15892 char *kwnames[] = {
15893 (char *) "self", NULL
15894 };
15895
15896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15898 if (SWIG_arg_fail(1)) SWIG_fail;
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15902
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 {
15907 resultobj = SWIG_From_int((int)(result));
15908 }
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj;
15917 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15918 int result;
15919 PyObject * obj0 = 0 ;
15920 char *kwnames[] = {
15921 (char *) "self", NULL
15922 };
15923
15924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15926 if (SWIG_arg_fail(1)) SWIG_fail;
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15930
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 {
15935 resultobj = SWIG_From_int((int)(result));
15936 }
15937 return resultobj;
15938 fail:
15939 return NULL;
15940 }
15941
15942
15943 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15944 PyObject *resultobj;
15945 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15946 int arg2 ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 char *kwnames[] = {
15950 (char *) "self",(char *) "orient", NULL
15951 };
15952
15953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15955 if (SWIG_arg_fail(1)) SWIG_fail;
15956 {
15957 arg2 = (int)(SWIG_As_int(obj1));
15958 if (SWIG_arg_fail(2)) SWIG_fail;
15959 }
15960 {
15961 PyThreadState* __tstate = wxPyBeginAllowThreads();
15962 (arg1)->SetOrientation(arg2);
15963
15964 wxPyEndAllowThreads(__tstate);
15965 if (PyErr_Occurred()) SWIG_fail;
15966 }
15967 Py_INCREF(Py_None); resultobj = Py_None;
15968 return resultobj;
15969 fail:
15970 return NULL;
15971 }
15972
15973
15974 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15975 PyObject *resultobj;
15976 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15977 int arg2 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self",(char *) "pos", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 arg2 = (int)(SWIG_As_int(obj1));
15989 if (SWIG_arg_fail(2)) SWIG_fail;
15990 }
15991 {
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 (arg1)->SetPosition(arg2);
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 Py_INCREF(Py_None); resultobj = Py_None;
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16006 PyObject *obj;
16007 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16008 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16009 Py_INCREF(obj);
16010 return Py_BuildValue((char *)"");
16011 }
16012 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj;
16014 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16015 int arg2 = (int) 0 ;
16016 int arg3 = (int) 0 ;
16017 wxScrollWinEvent *result;
16018 PyObject * obj0 = 0 ;
16019 PyObject * obj1 = 0 ;
16020 PyObject * obj2 = 0 ;
16021 char *kwnames[] = {
16022 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16023 };
16024
16025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16026 if (obj0) {
16027 {
16028 arg1 = (wxEventType)(SWIG_As_int(obj0));
16029 if (SWIG_arg_fail(1)) SWIG_fail;
16030 }
16031 }
16032 if (obj1) {
16033 {
16034 arg2 = (int)(SWIG_As_int(obj1));
16035 if (SWIG_arg_fail(2)) SWIG_fail;
16036 }
16037 }
16038 if (obj2) {
16039 {
16040 arg3 = (int)(SWIG_As_int(obj2));
16041 if (SWIG_arg_fail(3)) SWIG_fail;
16042 }
16043 }
16044 {
16045 PyThreadState* __tstate = wxPyBeginAllowThreads();
16046 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16047
16048 wxPyEndAllowThreads(__tstate);
16049 if (PyErr_Occurred()) SWIG_fail;
16050 }
16051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16052 return resultobj;
16053 fail:
16054 return NULL;
16055 }
16056
16057
16058 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16059 PyObject *resultobj;
16060 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16061 int result;
16062 PyObject * obj0 = 0 ;
16063 char *kwnames[] = {
16064 (char *) "self", NULL
16065 };
16066
16067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16069 if (SWIG_arg_fail(1)) SWIG_fail;
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 {
16078 resultobj = SWIG_From_int((int)(result));
16079 }
16080 return resultobj;
16081 fail:
16082 return NULL;
16083 }
16084
16085
16086 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16087 PyObject *resultobj;
16088 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16089 int result;
16090 PyObject * obj0 = 0 ;
16091 char *kwnames[] = {
16092 (char *) "self", NULL
16093 };
16094
16095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16097 if (SWIG_arg_fail(1)) SWIG_fail;
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16101
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 {
16106 resultobj = SWIG_From_int((int)(result));
16107 }
16108 return resultobj;
16109 fail:
16110 return NULL;
16111 }
16112
16113
16114 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16115 PyObject *resultobj;
16116 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16117 int arg2 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 char *kwnames[] = {
16121 (char *) "self",(char *) "orient", NULL
16122 };
16123
16124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16126 if (SWIG_arg_fail(1)) SWIG_fail;
16127 {
16128 arg2 = (int)(SWIG_As_int(obj1));
16129 if (SWIG_arg_fail(2)) SWIG_fail;
16130 }
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 (arg1)->SetOrientation(arg2);
16134
16135 wxPyEndAllowThreads(__tstate);
16136 if (PyErr_Occurred()) SWIG_fail;
16137 }
16138 Py_INCREF(Py_None); resultobj = Py_None;
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16146 PyObject *resultobj;
16147 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16148 int arg2 ;
16149 PyObject * obj0 = 0 ;
16150 PyObject * obj1 = 0 ;
16151 char *kwnames[] = {
16152 (char *) "self",(char *) "pos", NULL
16153 };
16154
16155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16157 if (SWIG_arg_fail(1)) SWIG_fail;
16158 {
16159 arg2 = (int)(SWIG_As_int(obj1));
16160 if (SWIG_arg_fail(2)) SWIG_fail;
16161 }
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 (arg1)->SetPosition(arg2);
16165
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 Py_INCREF(Py_None); resultobj = Py_None;
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16177 PyObject *obj;
16178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16179 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16180 Py_INCREF(obj);
16181 return Py_BuildValue((char *)"");
16182 }
16183 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj;
16185 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16186 wxMouseEvent *result;
16187 PyObject * obj0 = 0 ;
16188 char *kwnames[] = {
16189 (char *) "mouseType", NULL
16190 };
16191
16192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16193 if (obj0) {
16194 {
16195 arg1 = (wxEventType)(SWIG_As_int(obj0));
16196 if (SWIG_arg_fail(1)) SWIG_fail;
16197 }
16198 }
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16202
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 {
16207 resultobj = wxPyMake_wxObject(result, 1);
16208 }
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj;
16217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16218 bool result;
16219 PyObject * obj0 = 0 ;
16220 char *kwnames[] = {
16221 (char *) "self", NULL
16222 };
16223
16224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16226 if (SWIG_arg_fail(1)) SWIG_fail;
16227 {
16228 PyThreadState* __tstate = wxPyBeginAllowThreads();
16229 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16230
16231 wxPyEndAllowThreads(__tstate);
16232 if (PyErr_Occurred()) SWIG_fail;
16233 }
16234 {
16235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16236 }
16237 return resultobj;
16238 fail:
16239 return NULL;
16240 }
16241
16242
16243 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj;
16245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16246 int arg2 = (int) wxMOUSE_BTN_ANY ;
16247 bool result;
16248 PyObject * obj0 = 0 ;
16249 PyObject * obj1 = 0 ;
16250 char *kwnames[] = {
16251 (char *) "self",(char *) "but", NULL
16252 };
16253
16254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16256 if (SWIG_arg_fail(1)) SWIG_fail;
16257 if (obj1) {
16258 {
16259 arg2 = (int)(SWIG_As_int(obj1));
16260 if (SWIG_arg_fail(2)) SWIG_fail;
16261 }
16262 }
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16266
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 {
16271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16272 }
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj;
16281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16282 int arg2 = (int) wxMOUSE_BTN_ANY ;
16283 bool result;
16284 PyObject * obj0 = 0 ;
16285 PyObject * obj1 = 0 ;
16286 char *kwnames[] = {
16287 (char *) "self",(char *) "but", NULL
16288 };
16289
16290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) 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 if (obj1) {
16294 {
16295 arg2 = (int)(SWIG_As_int(obj1));
16296 if (SWIG_arg_fail(2)) SWIG_fail;
16297 }
16298 }
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16302
16303 wxPyEndAllowThreads(__tstate);
16304 if (PyErr_Occurred()) SWIG_fail;
16305 }
16306 {
16307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16308 }
16309 return resultobj;
16310 fail:
16311 return NULL;
16312 }
16313
16314
16315 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16316 PyObject *resultobj;
16317 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16318 int arg2 = (int) wxMOUSE_BTN_ANY ;
16319 bool result;
16320 PyObject * obj0 = 0 ;
16321 PyObject * obj1 = 0 ;
16322 char *kwnames[] = {
16323 (char *) "self",(char *) "but", NULL
16324 };
16325
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 if (obj1) {
16330 {
16331 arg2 = (int)(SWIG_As_int(obj1));
16332 if (SWIG_arg_fail(2)) SWIG_fail;
16333 }
16334 }
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16338
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16344 }
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj;
16353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16354 int arg2 ;
16355 bool result;
16356 PyObject * obj0 = 0 ;
16357 PyObject * obj1 = 0 ;
16358 char *kwnames[] = {
16359 (char *) "self",(char *) "but", NULL
16360 };
16361
16362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16364 if (SWIG_arg_fail(1)) SWIG_fail;
16365 {
16366 arg2 = (int)(SWIG_As_int(obj1));
16367 if (SWIG_arg_fail(2)) SWIG_fail;
16368 }
16369 {
16370 PyThreadState* __tstate = wxPyBeginAllowThreads();
16371 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16372
16373 wxPyEndAllowThreads(__tstate);
16374 if (PyErr_Occurred()) SWIG_fail;
16375 }
16376 {
16377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16378 }
16379 return resultobj;
16380 fail:
16381 return NULL;
16382 }
16383
16384
16385 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16386 PyObject *resultobj;
16387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16388 int arg2 ;
16389 bool result;
16390 PyObject * obj0 = 0 ;
16391 PyObject * obj1 = 0 ;
16392 char *kwnames[] = {
16393 (char *) "self",(char *) "but", NULL
16394 };
16395
16396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16398 if (SWIG_arg_fail(1)) SWIG_fail;
16399 {
16400 arg2 = (int)(SWIG_As_int(obj1));
16401 if (SWIG_arg_fail(2)) SWIG_fail;
16402 }
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16406
16407 wxPyEndAllowThreads(__tstate);
16408 if (PyErr_Occurred()) SWIG_fail;
16409 }
16410 {
16411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16412 }
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj;
16421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16422 int result;
16423 PyObject * obj0 = 0 ;
16424 char *kwnames[] = {
16425 (char *) "self", NULL
16426 };
16427
16428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16430 if (SWIG_arg_fail(1)) SWIG_fail;
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16434
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 {
16439 resultobj = SWIG_From_int((int)(result));
16440 }
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj;
16449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16450 bool result;
16451 PyObject * obj0 = 0 ;
16452 char *kwnames[] = {
16453 (char *) "self", NULL
16454 };
16455
16456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16458 if (SWIG_arg_fail(1)) SWIG_fail;
16459 {
16460 PyThreadState* __tstate = wxPyBeginAllowThreads();
16461 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16462
16463 wxPyEndAllowThreads(__tstate);
16464 if (PyErr_Occurred()) SWIG_fail;
16465 }
16466 {
16467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16468 }
16469 return resultobj;
16470 fail:
16471 return NULL;
16472 }
16473
16474
16475 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16476 PyObject *resultobj;
16477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16478 bool result;
16479 PyObject * obj0 = 0 ;
16480 char *kwnames[] = {
16481 (char *) "self", NULL
16482 };
16483
16484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16486 if (SWIG_arg_fail(1)) SWIG_fail;
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16490
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16496 }
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj;
16505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16506 bool result;
16507 PyObject * obj0 = 0 ;
16508 char *kwnames[] = {
16509 (char *) "self", NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16514 if (SWIG_arg_fail(1)) SWIG_fail;
16515 {
16516 PyThreadState* __tstate = wxPyBeginAllowThreads();
16517 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16518
16519 wxPyEndAllowThreads(__tstate);
16520 if (PyErr_Occurred()) SWIG_fail;
16521 }
16522 {
16523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16524 }
16525 return resultobj;
16526 fail:
16527 return NULL;
16528 }
16529
16530
16531 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16532 PyObject *resultobj;
16533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16534 bool result;
16535 PyObject * obj0 = 0 ;
16536 char *kwnames[] = {
16537 (char *) "self", NULL
16538 };
16539
16540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16542 if (SWIG_arg_fail(1)) SWIG_fail;
16543 {
16544 PyThreadState* __tstate = wxPyBeginAllowThreads();
16545 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16546
16547 wxPyEndAllowThreads(__tstate);
16548 if (PyErr_Occurred()) SWIG_fail;
16549 }
16550 {
16551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16552 }
16553 return resultobj;
16554 fail:
16555 return NULL;
16556 }
16557
16558
16559 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16560 PyObject *resultobj;
16561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16562 bool result;
16563 PyObject * obj0 = 0 ;
16564 char *kwnames[] = {
16565 (char *) "self", NULL
16566 };
16567
16568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16570 if (SWIG_arg_fail(1)) SWIG_fail;
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16574
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 {
16579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16580 }
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj;
16589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16590 bool result;
16591 PyObject * obj0 = 0 ;
16592 char *kwnames[] = {
16593 (char *) "self", NULL
16594 };
16595
16596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16598 if (SWIG_arg_fail(1)) SWIG_fail;
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16602
16603 wxPyEndAllowThreads(__tstate);
16604 if (PyErr_Occurred()) SWIG_fail;
16605 }
16606 {
16607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16608 }
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj;
16617 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16618 bool result;
16619 PyObject * obj0 = 0 ;
16620 char *kwnames[] = {
16621 (char *) "self", NULL
16622 };
16623
16624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16626 if (SWIG_arg_fail(1)) SWIG_fail;
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16630
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 {
16635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16636 }
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj;
16645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16646 bool result;
16647 PyObject * obj0 = 0 ;
16648 char *kwnames[] = {
16649 (char *) "self", NULL
16650 };
16651
16652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16654 if (SWIG_arg_fail(1)) SWIG_fail;
16655 {
16656 PyThreadState* __tstate = wxPyBeginAllowThreads();
16657 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16658
16659 wxPyEndAllowThreads(__tstate);
16660 if (PyErr_Occurred()) SWIG_fail;
16661 }
16662 {
16663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16664 }
16665 return resultobj;
16666 fail:
16667 return NULL;
16668 }
16669
16670
16671 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16672 PyObject *resultobj;
16673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16674 bool result;
16675 PyObject * obj0 = 0 ;
16676 char *kwnames[] = {
16677 (char *) "self", NULL
16678 };
16679
16680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16682 if (SWIG_arg_fail(1)) SWIG_fail;
16683 {
16684 PyThreadState* __tstate = wxPyBeginAllowThreads();
16685 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16686
16687 wxPyEndAllowThreads(__tstate);
16688 if (PyErr_Occurred()) SWIG_fail;
16689 }
16690 {
16691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16692 }
16693 return resultobj;
16694 fail:
16695 return NULL;
16696 }
16697
16698
16699 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16700 PyObject *resultobj;
16701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16702 bool result;
16703 PyObject * obj0 = 0 ;
16704 char *kwnames[] = {
16705 (char *) "self", NULL
16706 };
16707
16708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16710 if (SWIG_arg_fail(1)) SWIG_fail;
16711 {
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16714
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 {
16719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16720 }
16721 return resultobj;
16722 fail:
16723 return NULL;
16724 }
16725
16726
16727 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16728 PyObject *resultobj;
16729 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16730 bool result;
16731 PyObject * obj0 = 0 ;
16732 char *kwnames[] = {
16733 (char *) "self", NULL
16734 };
16735
16736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16738 if (SWIG_arg_fail(1)) SWIG_fail;
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16742
16743 wxPyEndAllowThreads(__tstate);
16744 if (PyErr_Occurred()) SWIG_fail;
16745 }
16746 {
16747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16748 }
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj;
16757 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16758 bool result;
16759 PyObject * obj0 = 0 ;
16760 char *kwnames[] = {
16761 (char *) "self", NULL
16762 };
16763
16764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16766 if (SWIG_arg_fail(1)) SWIG_fail;
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16770
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 {
16775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16776 }
16777 return resultobj;
16778 fail:
16779 return NULL;
16780 }
16781
16782
16783 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16784 PyObject *resultobj;
16785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16786 bool result;
16787 PyObject * obj0 = 0 ;
16788 char *kwnames[] = {
16789 (char *) "self", NULL
16790 };
16791
16792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16794 if (SWIG_arg_fail(1)) SWIG_fail;
16795 {
16796 PyThreadState* __tstate = wxPyBeginAllowThreads();
16797 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16798
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 {
16803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16804 }
16805 return resultobj;
16806 fail:
16807 return NULL;
16808 }
16809
16810
16811 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16812 PyObject *resultobj;
16813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16814 bool result;
16815 PyObject * obj0 = 0 ;
16816 char *kwnames[] = {
16817 (char *) "self", NULL
16818 };
16819
16820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16822 if (SWIG_arg_fail(1)) SWIG_fail;
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16826
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 {
16831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16832 }
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj;
16841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16842 bool result;
16843 PyObject * obj0 = 0 ;
16844 char *kwnames[] = {
16845 (char *) "self", NULL
16846 };
16847
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16850 if (SWIG_arg_fail(1)) SWIG_fail;
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 result = (bool)(arg1)->LeftIsDown();
16854
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 {
16859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16860 }
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj;
16869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16870 bool result;
16871 PyObject * obj0 = 0 ;
16872 char *kwnames[] = {
16873 (char *) "self", NULL
16874 };
16875
16876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16878 if (SWIG_arg_fail(1)) SWIG_fail;
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 result = (bool)(arg1)->MiddleIsDown();
16882
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 {
16887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16888 }
16889 return resultobj;
16890 fail:
16891 return NULL;
16892 }
16893
16894
16895 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16896 PyObject *resultobj;
16897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16898 bool result;
16899 PyObject * obj0 = 0 ;
16900 char *kwnames[] = {
16901 (char *) "self", NULL
16902 };
16903
16904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16906 if (SWIG_arg_fail(1)) SWIG_fail;
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = (bool)(arg1)->RightIsDown();
16910
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 {
16915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16916 }
16917 return resultobj;
16918 fail:
16919 return NULL;
16920 }
16921
16922
16923 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16924 PyObject *resultobj;
16925 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16926 bool result;
16927 PyObject * obj0 = 0 ;
16928 char *kwnames[] = {
16929 (char *) "self", NULL
16930 };
16931
16932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16934 if (SWIG_arg_fail(1)) SWIG_fail;
16935 {
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16938
16939 wxPyEndAllowThreads(__tstate);
16940 if (PyErr_Occurred()) SWIG_fail;
16941 }
16942 {
16943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16944 }
16945 return resultobj;
16946 fail:
16947 return NULL;
16948 }
16949
16950
16951 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16952 PyObject *resultobj;
16953 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16954 bool result;
16955 PyObject * obj0 = 0 ;
16956 char *kwnames[] = {
16957 (char *) "self", NULL
16958 };
16959
16960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16962 if (SWIG_arg_fail(1)) SWIG_fail;
16963 {
16964 PyThreadState* __tstate = wxPyBeginAllowThreads();
16965 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16966
16967 wxPyEndAllowThreads(__tstate);
16968 if (PyErr_Occurred()) SWIG_fail;
16969 }
16970 {
16971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16972 }
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj;
16981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16982 bool result;
16983 PyObject * obj0 = 0 ;
16984 char *kwnames[] = {
16985 (char *) "self", NULL
16986 };
16987
16988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16990 if (SWIG_arg_fail(1)) SWIG_fail;
16991 {
16992 PyThreadState* __tstate = wxPyBeginAllowThreads();
16993 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16994
16995 wxPyEndAllowThreads(__tstate);
16996 if (PyErr_Occurred()) SWIG_fail;
16997 }
16998 {
16999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17000 }
17001 return resultobj;
17002 fail:
17003 return NULL;
17004 }
17005
17006
17007 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj;
17009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17010 bool result;
17011 PyObject * obj0 = 0 ;
17012 char *kwnames[] = {
17013 (char *) "self", NULL
17014 };
17015
17016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17018 if (SWIG_arg_fail(1)) SWIG_fail;
17019 {
17020 PyThreadState* __tstate = wxPyBeginAllowThreads();
17021 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17022
17023 wxPyEndAllowThreads(__tstate);
17024 if (PyErr_Occurred()) SWIG_fail;
17025 }
17026 {
17027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17028 }
17029 return resultobj;
17030 fail:
17031 return NULL;
17032 }
17033
17034
17035 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17036 PyObject *resultobj;
17037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17038 wxPoint result;
17039 PyObject * obj0 = 0 ;
17040 char *kwnames[] = {
17041 (char *) "self", NULL
17042 };
17043
17044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17046 if (SWIG_arg_fail(1)) SWIG_fail;
17047 {
17048 PyThreadState* __tstate = wxPyBeginAllowThreads();
17049 result = (arg1)->GetPosition();
17050
17051 wxPyEndAllowThreads(__tstate);
17052 if (PyErr_Occurred()) SWIG_fail;
17053 }
17054 {
17055 wxPoint * resultptr;
17056 resultptr = new wxPoint((wxPoint &)(result));
17057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17058 }
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj;
17067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17068 long *arg2 = (long *) 0 ;
17069 long *arg3 = (long *) 0 ;
17070 long temp2 ;
17071 int res2 = 0 ;
17072 long temp3 ;
17073 int res3 = 0 ;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17080 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17083 if (SWIG_arg_fail(1)) SWIG_fail;
17084 {
17085 PyThreadState* __tstate = wxPyBeginAllowThreads();
17086 (arg1)->GetPosition(arg2,arg3);
17087
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 Py_INCREF(Py_None); resultobj = Py_None;
17092 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17093 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17094 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17095 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj;
17104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17105 wxDC *arg2 = 0 ;
17106 wxPoint result;
17107 PyObject * obj0 = 0 ;
17108 PyObject * obj1 = 0 ;
17109 char *kwnames[] = {
17110 (char *) "self",(char *) "dc", NULL
17111 };
17112
17113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17115 if (SWIG_arg_fail(1)) SWIG_fail;
17116 {
17117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17118 if (SWIG_arg_fail(2)) SWIG_fail;
17119 if (arg2 == NULL) {
17120 SWIG_null_ref("wxDC");
17121 }
17122 if (SWIG_arg_fail(2)) SWIG_fail;
17123 }
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17127
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 {
17132 wxPoint * resultptr;
17133 resultptr = new wxPoint((wxPoint &)(result));
17134 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17135 }
17136 return resultobj;
17137 fail:
17138 return NULL;
17139 }
17140
17141
17142 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17143 PyObject *resultobj;
17144 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17145 int result;
17146 PyObject * obj0 = 0 ;
17147 char *kwnames[] = {
17148 (char *) "self", NULL
17149 };
17150
17151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17153 if (SWIG_arg_fail(1)) SWIG_fail;
17154 {
17155 PyThreadState* __tstate = wxPyBeginAllowThreads();
17156 result = (int)((wxMouseEvent const *)arg1)->GetX();
17157
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 {
17162 resultobj = SWIG_From_int((int)(result));
17163 }
17164 return resultobj;
17165 fail:
17166 return NULL;
17167 }
17168
17169
17170 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17171 PyObject *resultobj;
17172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17173 int result;
17174 PyObject * obj0 = 0 ;
17175 char *kwnames[] = {
17176 (char *) "self", NULL
17177 };
17178
17179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17181 if (SWIG_arg_fail(1)) SWIG_fail;
17182 {
17183 PyThreadState* __tstate = wxPyBeginAllowThreads();
17184 result = (int)((wxMouseEvent const *)arg1)->GetY();
17185
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 {
17190 resultobj = SWIG_From_int((int)(result));
17191 }
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17201 int result;
17202 PyObject * obj0 = 0 ;
17203 char *kwnames[] = {
17204 (char *) "self", NULL
17205 };
17206
17207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17209 if (SWIG_arg_fail(1)) SWIG_fail;
17210 {
17211 PyThreadState* __tstate = wxPyBeginAllowThreads();
17212 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17213
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 {
17218 resultobj = SWIG_From_int((int)(result));
17219 }
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj;
17228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17229 int result;
17230 PyObject * obj0 = 0 ;
17231 char *kwnames[] = {
17232 (char *) "self", NULL
17233 };
17234
17235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17237 if (SWIG_arg_fail(1)) SWIG_fail;
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17241
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 {
17246 resultobj = SWIG_From_int((int)(result));
17247 }
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 int result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",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 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17269
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = SWIG_From_int((int)(result));
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17285 bool result;
17286 PyObject * obj0 = 0 ;
17287 char *kwnames[] = {
17288 (char *) "self", NULL
17289 };
17290
17291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17293 if (SWIG_arg_fail(1)) SWIG_fail;
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17297
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 {
17302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17303 }
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj;
17312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17313 int arg2 ;
17314 PyObject * obj0 = 0 ;
17315 PyObject * obj1 = 0 ;
17316 char *kwnames[] = {
17317 (char *) "self",(char *) "m_x", NULL
17318 };
17319
17320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17322 if (SWIG_arg_fail(1)) SWIG_fail;
17323 {
17324 arg2 = (int)(SWIG_As_int(obj1));
17325 if (SWIG_arg_fail(2)) SWIG_fail;
17326 }
17327 if (arg1) (arg1)->m_x = arg2;
17328
17329 Py_INCREF(Py_None); resultobj = Py_None;
17330 return resultobj;
17331 fail:
17332 return NULL;
17333 }
17334
17335
17336 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17337 PyObject *resultobj;
17338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17339 int result;
17340 PyObject * obj0 = 0 ;
17341 char *kwnames[] = {
17342 (char *) "self", NULL
17343 };
17344
17345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17347 if (SWIG_arg_fail(1)) SWIG_fail;
17348 result = (int) ((arg1)->m_x);
17349
17350 {
17351 resultobj = SWIG_From_int((int)(result));
17352 }
17353 return resultobj;
17354 fail:
17355 return NULL;
17356 }
17357
17358
17359 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17360 PyObject *resultobj;
17361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17362 int arg2 ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 char *kwnames[] = {
17366 (char *) "self",(char *) "m_y", NULL
17367 };
17368
17369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17371 if (SWIG_arg_fail(1)) SWIG_fail;
17372 {
17373 arg2 = (int)(SWIG_As_int(obj1));
17374 if (SWIG_arg_fail(2)) SWIG_fail;
17375 }
17376 if (arg1) (arg1)->m_y = arg2;
17377
17378 Py_INCREF(Py_None); resultobj = Py_None;
17379 return resultobj;
17380 fail:
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj;
17387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17388 int result;
17389 PyObject * obj0 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 result = (int) ((arg1)->m_y);
17398
17399 {
17400 resultobj = SWIG_From_int((int)(result));
17401 }
17402 return resultobj;
17403 fail:
17404 return NULL;
17405 }
17406
17407
17408 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17409 PyObject *resultobj;
17410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17411 bool arg2 ;
17412 PyObject * obj0 = 0 ;
17413 PyObject * obj1 = 0 ;
17414 char *kwnames[] = {
17415 (char *) "self",(char *) "m_leftDown", NULL
17416 };
17417
17418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17420 if (SWIG_arg_fail(1)) SWIG_fail;
17421 {
17422 arg2 = (bool)(SWIG_As_bool(obj1));
17423 if (SWIG_arg_fail(2)) SWIG_fail;
17424 }
17425 if (arg1) (arg1)->m_leftDown = arg2;
17426
17427 Py_INCREF(Py_None); resultobj = Py_None;
17428 return resultobj;
17429 fail:
17430 return NULL;
17431 }
17432
17433
17434 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17435 PyObject *resultobj;
17436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17437 bool result;
17438 PyObject * obj0 = 0 ;
17439 char *kwnames[] = {
17440 (char *) "self", NULL
17441 };
17442
17443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17445 if (SWIG_arg_fail(1)) SWIG_fail;
17446 result = (bool) ((arg1)->m_leftDown);
17447
17448 {
17449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 bool arg2 ;
17461 PyObject * obj0 = 0 ;
17462 PyObject * obj1 = 0 ;
17463 char *kwnames[] = {
17464 (char *) "self",(char *) "m_middleDown", NULL
17465 };
17466
17467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17469 if (SWIG_arg_fail(1)) SWIG_fail;
17470 {
17471 arg2 = (bool)(SWIG_As_bool(obj1));
17472 if (SWIG_arg_fail(2)) SWIG_fail;
17473 }
17474 if (arg1) (arg1)->m_middleDown = arg2;
17475
17476 Py_INCREF(Py_None); resultobj = Py_None;
17477 return resultobj;
17478 fail:
17479 return NULL;
17480 }
17481
17482
17483 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17484 PyObject *resultobj;
17485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17486 bool result;
17487 PyObject * obj0 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 result = (bool) ((arg1)->m_middleDown);
17496
17497 {
17498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17499 }
17500 return resultobj;
17501 fail:
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17509 bool arg2 ;
17510 PyObject * obj0 = 0 ;
17511 PyObject * obj1 = 0 ;
17512 char *kwnames[] = {
17513 (char *) "self",(char *) "m_rightDown", NULL
17514 };
17515
17516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17518 if (SWIG_arg_fail(1)) SWIG_fail;
17519 {
17520 arg2 = (bool)(SWIG_As_bool(obj1));
17521 if (SWIG_arg_fail(2)) SWIG_fail;
17522 }
17523 if (arg1) (arg1)->m_rightDown = arg2;
17524
17525 Py_INCREF(Py_None); resultobj = Py_None;
17526 return resultobj;
17527 fail:
17528 return NULL;
17529 }
17530
17531
17532 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17533 PyObject *resultobj;
17534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17535 bool result;
17536 PyObject * obj0 = 0 ;
17537 char *kwnames[] = {
17538 (char *) "self", NULL
17539 };
17540
17541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17543 if (SWIG_arg_fail(1)) SWIG_fail;
17544 result = (bool) ((arg1)->m_rightDown);
17545
17546 {
17547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17548 }
17549 return resultobj;
17550 fail:
17551 return NULL;
17552 }
17553
17554
17555 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj;
17557 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17558 bool arg2 ;
17559 PyObject * obj0 = 0 ;
17560 PyObject * obj1 = 0 ;
17561 char *kwnames[] = {
17562 (char *) "self",(char *) "m_controlDown", NULL
17563 };
17564
17565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17567 if (SWIG_arg_fail(1)) SWIG_fail;
17568 {
17569 arg2 = (bool)(SWIG_As_bool(obj1));
17570 if (SWIG_arg_fail(2)) SWIG_fail;
17571 }
17572 if (arg1) (arg1)->m_controlDown = arg2;
17573
17574 Py_INCREF(Py_None); resultobj = Py_None;
17575 return resultobj;
17576 fail:
17577 return NULL;
17578 }
17579
17580
17581 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17582 PyObject *resultobj;
17583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17584 bool result;
17585 PyObject * obj0 = 0 ;
17586 char *kwnames[] = {
17587 (char *) "self", NULL
17588 };
17589
17590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17592 if (SWIG_arg_fail(1)) SWIG_fail;
17593 result = (bool) ((arg1)->m_controlDown);
17594
17595 {
17596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17597 }
17598 return resultobj;
17599 fail:
17600 return NULL;
17601 }
17602
17603
17604 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17605 PyObject *resultobj;
17606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17607 bool arg2 ;
17608 PyObject * obj0 = 0 ;
17609 PyObject * obj1 = 0 ;
17610 char *kwnames[] = {
17611 (char *) "self",(char *) "m_shiftDown", NULL
17612 };
17613
17614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17616 if (SWIG_arg_fail(1)) SWIG_fail;
17617 {
17618 arg2 = (bool)(SWIG_As_bool(obj1));
17619 if (SWIG_arg_fail(2)) SWIG_fail;
17620 }
17621 if (arg1) (arg1)->m_shiftDown = arg2;
17622
17623 Py_INCREF(Py_None); resultobj = Py_None;
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17631 PyObject *resultobj;
17632 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17633 bool result;
17634 PyObject * obj0 = 0 ;
17635 char *kwnames[] = {
17636 (char *) "self", NULL
17637 };
17638
17639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17641 if (SWIG_arg_fail(1)) SWIG_fail;
17642 result = (bool) ((arg1)->m_shiftDown);
17643
17644 {
17645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj;
17655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17656 bool arg2 ;
17657 PyObject * obj0 = 0 ;
17658 PyObject * obj1 = 0 ;
17659 char *kwnames[] = {
17660 (char *) "self",(char *) "m_altDown", NULL
17661 };
17662
17663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17665 if (SWIG_arg_fail(1)) SWIG_fail;
17666 {
17667 arg2 = (bool)(SWIG_As_bool(obj1));
17668 if (SWIG_arg_fail(2)) SWIG_fail;
17669 }
17670 if (arg1) (arg1)->m_altDown = arg2;
17671
17672 Py_INCREF(Py_None); resultobj = Py_None;
17673 return resultobj;
17674 fail:
17675 return NULL;
17676 }
17677
17678
17679 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17680 PyObject *resultobj;
17681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17682 bool result;
17683 PyObject * obj0 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "self", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17690 if (SWIG_arg_fail(1)) SWIG_fail;
17691 result = (bool) ((arg1)->m_altDown);
17692
17693 {
17694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17695 }
17696 return resultobj;
17697 fail:
17698 return NULL;
17699 }
17700
17701
17702 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17703 PyObject *resultobj;
17704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17705 bool arg2 ;
17706 PyObject * obj0 = 0 ;
17707 PyObject * obj1 = 0 ;
17708 char *kwnames[] = {
17709 (char *) "self",(char *) "m_metaDown", NULL
17710 };
17711
17712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17714 if (SWIG_arg_fail(1)) SWIG_fail;
17715 {
17716 arg2 = (bool)(SWIG_As_bool(obj1));
17717 if (SWIG_arg_fail(2)) SWIG_fail;
17718 }
17719 if (arg1) (arg1)->m_metaDown = arg2;
17720
17721 Py_INCREF(Py_None); resultobj = Py_None;
17722 return resultobj;
17723 fail:
17724 return NULL;
17725 }
17726
17727
17728 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17729 PyObject *resultobj;
17730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17731 bool result;
17732 PyObject * obj0 = 0 ;
17733 char *kwnames[] = {
17734 (char *) "self", NULL
17735 };
17736
17737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17739 if (SWIG_arg_fail(1)) SWIG_fail;
17740 result = (bool) ((arg1)->m_metaDown);
17741
17742 {
17743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17754 int arg2 ;
17755 PyObject * obj0 = 0 ;
17756 PyObject * obj1 = 0 ;
17757 char *kwnames[] = {
17758 (char *) "self",(char *) "m_wheelRotation", NULL
17759 };
17760
17761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17763 if (SWIG_arg_fail(1)) SWIG_fail;
17764 {
17765 arg2 = (int)(SWIG_As_int(obj1));
17766 if (SWIG_arg_fail(2)) SWIG_fail;
17767 }
17768 if (arg1) (arg1)->m_wheelRotation = arg2;
17769
17770 Py_INCREF(Py_None); resultobj = Py_None;
17771 return resultobj;
17772 fail:
17773 return NULL;
17774 }
17775
17776
17777 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17778 PyObject *resultobj;
17779 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17780 int result;
17781 PyObject * obj0 = 0 ;
17782 char *kwnames[] = {
17783 (char *) "self", NULL
17784 };
17785
17786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17788 if (SWIG_arg_fail(1)) SWIG_fail;
17789 result = (int) ((arg1)->m_wheelRotation);
17790
17791 {
17792 resultobj = SWIG_From_int((int)(result));
17793 }
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj;
17802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17803 int arg2 ;
17804 PyObject * obj0 = 0 ;
17805 PyObject * obj1 = 0 ;
17806 char *kwnames[] = {
17807 (char *) "self",(char *) "m_wheelDelta", NULL
17808 };
17809
17810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17812 if (SWIG_arg_fail(1)) SWIG_fail;
17813 {
17814 arg2 = (int)(SWIG_As_int(obj1));
17815 if (SWIG_arg_fail(2)) SWIG_fail;
17816 }
17817 if (arg1) (arg1)->m_wheelDelta = arg2;
17818
17819 Py_INCREF(Py_None); resultobj = Py_None;
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj;
17828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17829 int result;
17830 PyObject * obj0 = 0 ;
17831 char *kwnames[] = {
17832 (char *) "self", NULL
17833 };
17834
17835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17837 if (SWIG_arg_fail(1)) SWIG_fail;
17838 result = (int) ((arg1)->m_wheelDelta);
17839
17840 {
17841 resultobj = SWIG_From_int((int)(result));
17842 }
17843 return resultobj;
17844 fail:
17845 return NULL;
17846 }
17847
17848
17849 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj;
17851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17852 int arg2 ;
17853 PyObject * obj0 = 0 ;
17854 PyObject * obj1 = 0 ;
17855 char *kwnames[] = {
17856 (char *) "self",(char *) "m_linesPerAction", NULL
17857 };
17858
17859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17861 if (SWIG_arg_fail(1)) SWIG_fail;
17862 {
17863 arg2 = (int)(SWIG_As_int(obj1));
17864 if (SWIG_arg_fail(2)) SWIG_fail;
17865 }
17866 if (arg1) (arg1)->m_linesPerAction = arg2;
17867
17868 Py_INCREF(Py_None); resultobj = Py_None;
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17876 PyObject *resultobj;
17877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17878 int result;
17879 PyObject * obj0 = 0 ;
17880 char *kwnames[] = {
17881 (char *) "self", NULL
17882 };
17883
17884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17886 if (SWIG_arg_fail(1)) SWIG_fail;
17887 result = (int) ((arg1)->m_linesPerAction);
17888
17889 {
17890 resultobj = SWIG_From_int((int)(result));
17891 }
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17899 PyObject *obj;
17900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17901 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17902 Py_INCREF(obj);
17903 return Py_BuildValue((char *)"");
17904 }
17905 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj;
17907 int arg1 = (int) 0 ;
17908 int arg2 = (int) 0 ;
17909 wxSetCursorEvent *result;
17910 PyObject * obj0 = 0 ;
17911 PyObject * obj1 = 0 ;
17912 char *kwnames[] = {
17913 (char *) "x",(char *) "y", NULL
17914 };
17915
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17917 if (obj0) {
17918 {
17919 arg1 = (int)(SWIG_As_int(obj0));
17920 if (SWIG_arg_fail(1)) SWIG_fail;
17921 }
17922 }
17923 if (obj1) {
17924 {
17925 arg2 = (int)(SWIG_As_int(obj1));
17926 if (SWIG_arg_fail(2)) SWIG_fail;
17927 }
17928 }
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17932
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17937 return resultobj;
17938 fail:
17939 return NULL;
17940 }
17941
17942
17943 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj;
17945 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17946 int result;
17947 PyObject * obj0 = 0 ;
17948 char *kwnames[] = {
17949 (char *) "self", NULL
17950 };
17951
17952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17954 if (SWIG_arg_fail(1)) SWIG_fail;
17955 {
17956 PyThreadState* __tstate = wxPyBeginAllowThreads();
17957 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17958
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 {
17963 resultobj = SWIG_From_int((int)(result));
17964 }
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17972 PyObject *resultobj;
17973 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17974 int result;
17975 PyObject * obj0 = 0 ;
17976 char *kwnames[] = {
17977 (char *) "self", NULL
17978 };
17979
17980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17982 if (SWIG_arg_fail(1)) SWIG_fail;
17983 {
17984 PyThreadState* __tstate = wxPyBeginAllowThreads();
17985 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17986
17987 wxPyEndAllowThreads(__tstate);
17988 if (PyErr_Occurred()) SWIG_fail;
17989 }
17990 {
17991 resultobj = SWIG_From_int((int)(result));
17992 }
17993 return resultobj;
17994 fail:
17995 return NULL;
17996 }
17997
17998
17999 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18000 PyObject *resultobj;
18001 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18002 wxCursor *arg2 = 0 ;
18003 PyObject * obj0 = 0 ;
18004 PyObject * obj1 = 0 ;
18005 char *kwnames[] = {
18006 (char *) "self",(char *) "cursor", NULL
18007 };
18008
18009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18011 if (SWIG_arg_fail(1)) SWIG_fail;
18012 {
18013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18014 if (SWIG_arg_fail(2)) SWIG_fail;
18015 if (arg2 == NULL) {
18016 SWIG_null_ref("wxCursor");
18017 }
18018 if (SWIG_arg_fail(2)) SWIG_fail;
18019 }
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 (arg1)->SetCursor((wxCursor const &)*arg2);
18023
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 Py_INCREF(Py_None); resultobj = Py_None;
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj;
18036 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18037 wxCursor *result;
18038 PyObject * obj0 = 0 ;
18039 char *kwnames[] = {
18040 (char *) "self", NULL
18041 };
18042
18043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18045 if (SWIG_arg_fail(1)) SWIG_fail;
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 {
18049 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18050 result = (wxCursor *) &_result_ref;
18051 }
18052
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 {
18057 wxCursor* resultptr = new wxCursor(*result);
18058 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18059 }
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18067 PyObject *resultobj;
18068 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18069 bool result;
18070 PyObject * obj0 = 0 ;
18071 char *kwnames[] = {
18072 (char *) "self", NULL
18073 };
18074
18075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18077 if (SWIG_arg_fail(1)) SWIG_fail;
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18081
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 {
18086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18087 }
18088 return resultobj;
18089 fail:
18090 return NULL;
18091 }
18092
18093
18094 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18095 PyObject *obj;
18096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18097 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18098 Py_INCREF(obj);
18099 return Py_BuildValue((char *)"");
18100 }
18101 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18102 PyObject *resultobj;
18103 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18104 wxKeyEvent *result;
18105 PyObject * obj0 = 0 ;
18106 char *kwnames[] = {
18107 (char *) "keyType", NULL
18108 };
18109
18110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18111 if (obj0) {
18112 {
18113 arg1 = (wxEventType)(SWIG_As_int(obj0));
18114 if (SWIG_arg_fail(1)) SWIG_fail;
18115 }
18116 }
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18132 PyObject *resultobj;
18133 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18134 bool result;
18135 PyObject * obj0 = 0 ;
18136 char *kwnames[] = {
18137 (char *) "self", NULL
18138 };
18139
18140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18142 if (SWIG_arg_fail(1)) SWIG_fail;
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18146
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 {
18151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18152 }
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj;
18161 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18162 bool result;
18163 PyObject * obj0 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18174
18175 wxPyEndAllowThreads(__tstate);
18176 if (PyErr_Occurred()) SWIG_fail;
18177 }
18178 {
18179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18180 }
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj;
18189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18190 bool result;
18191 PyObject * obj0 = 0 ;
18192 char *kwnames[] = {
18193 (char *) "self", NULL
18194 };
18195
18196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18198 if (SWIG_arg_fail(1)) SWIG_fail;
18199 {
18200 PyThreadState* __tstate = wxPyBeginAllowThreads();
18201 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18202
18203 wxPyEndAllowThreads(__tstate);
18204 if (PyErr_Occurred()) SWIG_fail;
18205 }
18206 {
18207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18208 }
18209 return resultobj;
18210 fail:
18211 return NULL;
18212 }
18213
18214
18215 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18216 PyObject *resultobj;
18217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18218 bool result;
18219 PyObject * obj0 = 0 ;
18220 char *kwnames[] = {
18221 (char *) "self", NULL
18222 };
18223
18224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18226 if (SWIG_arg_fail(1)) SWIG_fail;
18227 {
18228 PyThreadState* __tstate = wxPyBeginAllowThreads();
18229 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18230
18231 wxPyEndAllowThreads(__tstate);
18232 if (PyErr_Occurred()) SWIG_fail;
18233 }
18234 {
18235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18236 }
18237 return resultobj;
18238 fail:
18239 return NULL;
18240 }
18241
18242
18243 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18244 PyObject *resultobj;
18245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18246 bool result;
18247 PyObject * obj0 = 0 ;
18248 char *kwnames[] = {
18249 (char *) "self", NULL
18250 };
18251
18252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18254 if (SWIG_arg_fail(1)) SWIG_fail;
18255 {
18256 PyThreadState* __tstate = wxPyBeginAllowThreads();
18257 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18258
18259 wxPyEndAllowThreads(__tstate);
18260 if (PyErr_Occurred()) SWIG_fail;
18261 }
18262 {
18263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18264 }
18265 return resultobj;
18266 fail:
18267 return NULL;
18268 }
18269
18270
18271 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18272 PyObject *resultobj;
18273 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18274 bool result;
18275 PyObject * obj0 = 0 ;
18276 char *kwnames[] = {
18277 (char *) "self", NULL
18278 };
18279
18280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18282 if (SWIG_arg_fail(1)) SWIG_fail;
18283 {
18284 PyThreadState* __tstate = wxPyBeginAllowThreads();
18285 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18286
18287 wxPyEndAllowThreads(__tstate);
18288 if (PyErr_Occurred()) SWIG_fail;
18289 }
18290 {
18291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18292 }
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18302 int result;
18303 PyObject * obj0 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18314
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 {
18319 resultobj = SWIG_From_int((int)(result));
18320 }
18321 return resultobj;
18322 fail:
18323 return NULL;
18324 }
18325
18326
18327 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18328 PyObject *resultobj;
18329 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18330 int result;
18331 PyObject * obj0 = 0 ;
18332 char *kwnames[] = {
18333 (char *) "self", NULL
18334 };
18335
18336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18338 if (SWIG_arg_fail(1)) SWIG_fail;
18339 {
18340 PyThreadState* __tstate = wxPyBeginAllowThreads();
18341 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18342
18343 wxPyEndAllowThreads(__tstate);
18344 if (PyErr_Occurred()) SWIG_fail;
18345 }
18346 {
18347 resultobj = SWIG_From_int((int)(result));
18348 }
18349 return resultobj;
18350 fail:
18351 return NULL;
18352 }
18353
18354
18355 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18356 PyObject *resultobj;
18357 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18358 unsigned int result;
18359 PyObject * obj0 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18369 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18370
18371 wxPyEndAllowThreads(__tstate);
18372 if (PyErr_Occurred()) SWIG_fail;
18373 }
18374 {
18375 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18376 }
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj;
18385 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18386 unsigned int result;
18387 PyObject * obj0 = 0 ;
18388 char *kwnames[] = {
18389 (char *) "self", NULL
18390 };
18391
18392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18394 if (SWIG_arg_fail(1)) SWIG_fail;
18395 {
18396 PyThreadState* __tstate = wxPyBeginAllowThreads();
18397 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18398
18399 wxPyEndAllowThreads(__tstate);
18400 if (PyErr_Occurred()) SWIG_fail;
18401 }
18402 {
18403 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18404 }
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18412 PyObject *resultobj;
18413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18414 wxPoint result;
18415 PyObject * obj0 = 0 ;
18416 char *kwnames[] = {
18417 (char *) "self", NULL
18418 };
18419
18420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18422 if (SWIG_arg_fail(1)) SWIG_fail;
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (arg1)->GetPosition();
18426
18427 wxPyEndAllowThreads(__tstate);
18428 if (PyErr_Occurred()) SWIG_fail;
18429 }
18430 {
18431 wxPoint * resultptr;
18432 resultptr = new wxPoint((wxPoint &)(result));
18433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18434 }
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj;
18443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18444 long *arg2 = (long *) 0 ;
18445 long *arg3 = (long *) 0 ;
18446 long temp2 ;
18447 int res2 = 0 ;
18448 long temp3 ;
18449 int res3 = 0 ;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18456 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18459 if (SWIG_arg_fail(1)) SWIG_fail;
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 (arg1)->GetPosition(arg2,arg3);
18463
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 Py_INCREF(Py_None); resultobj = Py_None;
18468 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18469 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18470 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18471 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18481 int result;
18482 PyObject * obj0 = 0 ;
18483 char *kwnames[] = {
18484 (char *) "self", NULL
18485 };
18486
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",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 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 result = (int)((wxKeyEvent const *)arg1)->GetX();
18493
18494 wxPyEndAllowThreads(__tstate);
18495 if (PyErr_Occurred()) SWIG_fail;
18496 }
18497 {
18498 resultobj = SWIG_From_int((int)(result));
18499 }
18500 return resultobj;
18501 fail:
18502 return NULL;
18503 }
18504
18505
18506 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18507 PyObject *resultobj;
18508 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18509 int result;
18510 PyObject * obj0 = 0 ;
18511 char *kwnames[] = {
18512 (char *) "self", NULL
18513 };
18514
18515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18517 if (SWIG_arg_fail(1)) SWIG_fail;
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 result = (int)((wxKeyEvent const *)arg1)->GetY();
18521
18522 wxPyEndAllowThreads(__tstate);
18523 if (PyErr_Occurred()) SWIG_fail;
18524 }
18525 {
18526 resultobj = SWIG_From_int((int)(result));
18527 }
18528 return resultobj;
18529 fail:
18530 return NULL;
18531 }
18532
18533
18534 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18535 PyObject *resultobj;
18536 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18537 int arg2 ;
18538 PyObject * obj0 = 0 ;
18539 PyObject * obj1 = 0 ;
18540 char *kwnames[] = {
18541 (char *) "self",(char *) "m_x", NULL
18542 };
18543
18544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18546 if (SWIG_arg_fail(1)) SWIG_fail;
18547 {
18548 arg2 = (int)(SWIG_As_int(obj1));
18549 if (SWIG_arg_fail(2)) SWIG_fail;
18550 }
18551 if (arg1) (arg1)->m_x = arg2;
18552
18553 Py_INCREF(Py_None); resultobj = Py_None;
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18561 PyObject *resultobj;
18562 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18563 int result;
18564 PyObject * obj0 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 result = (int) ((arg1)->m_x);
18573
18574 {
18575 resultobj = SWIG_From_int((int)(result));
18576 }
18577 return resultobj;
18578 fail:
18579 return NULL;
18580 }
18581
18582
18583 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18584 PyObject *resultobj;
18585 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18586 int arg2 ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 char *kwnames[] = {
18590 (char *) "self",(char *) "m_y", NULL
18591 };
18592
18593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18595 if (SWIG_arg_fail(1)) SWIG_fail;
18596 {
18597 arg2 = (int)(SWIG_As_int(obj1));
18598 if (SWIG_arg_fail(2)) SWIG_fail;
18599 }
18600 if (arg1) (arg1)->m_y = arg2;
18601
18602 Py_INCREF(Py_None); resultobj = Py_None;
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18610 PyObject *resultobj;
18611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18612 int result;
18613 PyObject * obj0 = 0 ;
18614 char *kwnames[] = {
18615 (char *) "self", NULL
18616 };
18617
18618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18620 if (SWIG_arg_fail(1)) SWIG_fail;
18621 result = (int) ((arg1)->m_y);
18622
18623 {
18624 resultobj = SWIG_From_int((int)(result));
18625 }
18626 return resultobj;
18627 fail:
18628 return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18635 long arg2 ;
18636 PyObject * obj0 = 0 ;
18637 PyObject * obj1 = 0 ;
18638 char *kwnames[] = {
18639 (char *) "self",(char *) "m_keyCode", NULL
18640 };
18641
18642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18644 if (SWIG_arg_fail(1)) SWIG_fail;
18645 {
18646 arg2 = (long)(SWIG_As_long(obj1));
18647 if (SWIG_arg_fail(2)) SWIG_fail;
18648 }
18649 if (arg1) (arg1)->m_keyCode = arg2;
18650
18651 Py_INCREF(Py_None); resultobj = Py_None;
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18659 PyObject *resultobj;
18660 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18661 long result;
18662 PyObject * obj0 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 result = (long) ((arg1)->m_keyCode);
18671
18672 {
18673 resultobj = SWIG_From_long((long)(result));
18674 }
18675 return resultobj;
18676 fail:
18677 return NULL;
18678 }
18679
18680
18681 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj;
18683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18684 bool arg2 ;
18685 PyObject * obj0 = 0 ;
18686 PyObject * obj1 = 0 ;
18687 char *kwnames[] = {
18688 (char *) "self",(char *) "m_controlDown", NULL
18689 };
18690
18691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18693 if (SWIG_arg_fail(1)) SWIG_fail;
18694 {
18695 arg2 = (bool)(SWIG_As_bool(obj1));
18696 if (SWIG_arg_fail(2)) SWIG_fail;
18697 }
18698 if (arg1) (arg1)->m_controlDown = arg2;
18699
18700 Py_INCREF(Py_None); resultobj = Py_None;
18701 return resultobj;
18702 fail:
18703 return NULL;
18704 }
18705
18706
18707 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18708 PyObject *resultobj;
18709 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18710 bool result;
18711 PyObject * obj0 = 0 ;
18712 char *kwnames[] = {
18713 (char *) "self", NULL
18714 };
18715
18716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18718 if (SWIG_arg_fail(1)) SWIG_fail;
18719 result = (bool) ((arg1)->m_controlDown);
18720
18721 {
18722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18723 }
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj;
18732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18733 bool arg2 ;
18734 PyObject * obj0 = 0 ;
18735 PyObject * obj1 = 0 ;
18736 char *kwnames[] = {
18737 (char *) "self",(char *) "m_shiftDown", NULL
18738 };
18739
18740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18742 if (SWIG_arg_fail(1)) SWIG_fail;
18743 {
18744 arg2 = (bool)(SWIG_As_bool(obj1));
18745 if (SWIG_arg_fail(2)) SWIG_fail;
18746 }
18747 if (arg1) (arg1)->m_shiftDown = arg2;
18748
18749 Py_INCREF(Py_None); resultobj = Py_None;
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18759 bool result;
18760 PyObject * obj0 = 0 ;
18761 char *kwnames[] = {
18762 (char *) "self", NULL
18763 };
18764
18765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18767 if (SWIG_arg_fail(1)) SWIG_fail;
18768 result = (bool) ((arg1)->m_shiftDown);
18769
18770 {
18771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18772 }
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj;
18781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18782 bool arg2 ;
18783 PyObject * obj0 = 0 ;
18784 PyObject * obj1 = 0 ;
18785 char *kwnames[] = {
18786 (char *) "self",(char *) "m_altDown", NULL
18787 };
18788
18789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18791 if (SWIG_arg_fail(1)) SWIG_fail;
18792 {
18793 arg2 = (bool)(SWIG_As_bool(obj1));
18794 if (SWIG_arg_fail(2)) SWIG_fail;
18795 }
18796 if (arg1) (arg1)->m_altDown = arg2;
18797
18798 Py_INCREF(Py_None); resultobj = Py_None;
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18806 PyObject *resultobj;
18807 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18808 bool result;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "self", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 result = (bool) ((arg1)->m_altDown);
18818
18819 {
18820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18821 }
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18831 bool arg2 ;
18832 PyObject * obj0 = 0 ;
18833 PyObject * obj1 = 0 ;
18834 char *kwnames[] = {
18835 (char *) "self",(char *) "m_metaDown", NULL
18836 };
18837
18838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18840 if (SWIG_arg_fail(1)) SWIG_fail;
18841 {
18842 arg2 = (bool)(SWIG_As_bool(obj1));
18843 if (SWIG_arg_fail(2)) SWIG_fail;
18844 }
18845 if (arg1) (arg1)->m_metaDown = arg2;
18846
18847 Py_INCREF(Py_None); resultobj = Py_None;
18848 return resultobj;
18849 fail:
18850 return NULL;
18851 }
18852
18853
18854 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18855 PyObject *resultobj;
18856 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18857 bool result;
18858 PyObject * obj0 = 0 ;
18859 char *kwnames[] = {
18860 (char *) "self", NULL
18861 };
18862
18863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18865 if (SWIG_arg_fail(1)) SWIG_fail;
18866 result = (bool) ((arg1)->m_metaDown);
18867
18868 {
18869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18870 }
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18878 PyObject *resultobj;
18879 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18880 bool arg2 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char *kwnames[] = {
18884 (char *) "self",(char *) "m_scanCode", NULL
18885 };
18886
18887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18889 if (SWIG_arg_fail(1)) SWIG_fail;
18890 {
18891 arg2 = (bool)(SWIG_As_bool(obj1));
18892 if (SWIG_arg_fail(2)) SWIG_fail;
18893 }
18894 if (arg1) (arg1)->m_scanCode = arg2;
18895
18896 Py_INCREF(Py_None); resultobj = Py_None;
18897 return resultobj;
18898 fail:
18899 return NULL;
18900 }
18901
18902
18903 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18904 PyObject *resultobj;
18905 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18906 bool result;
18907 PyObject * obj0 = 0 ;
18908 char *kwnames[] = {
18909 (char *) "self", NULL
18910 };
18911
18912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18914 if (SWIG_arg_fail(1)) SWIG_fail;
18915 result = (bool) ((arg1)->m_scanCode);
18916
18917 {
18918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18919 }
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj;
18928 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18929 unsigned int arg2 ;
18930 PyObject * obj0 = 0 ;
18931 PyObject * obj1 = 0 ;
18932 char *kwnames[] = {
18933 (char *) "self",(char *) "m_rawCode", NULL
18934 };
18935
18936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18938 if (SWIG_arg_fail(1)) SWIG_fail;
18939 {
18940 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18941 if (SWIG_arg_fail(2)) SWIG_fail;
18942 }
18943 if (arg1) (arg1)->m_rawCode = arg2;
18944
18945 Py_INCREF(Py_None); resultobj = Py_None;
18946 return resultobj;
18947 fail:
18948 return NULL;
18949 }
18950
18951
18952 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18953 PyObject *resultobj;
18954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18955 unsigned int result;
18956 PyObject * obj0 = 0 ;
18957 char *kwnames[] = {
18958 (char *) "self", NULL
18959 };
18960
18961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18963 if (SWIG_arg_fail(1)) SWIG_fail;
18964 result = (unsigned int) ((arg1)->m_rawCode);
18965
18966 {
18967 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18968 }
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj;
18977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18978 unsigned int arg2 ;
18979 PyObject * obj0 = 0 ;
18980 PyObject * obj1 = 0 ;
18981 char *kwnames[] = {
18982 (char *) "self",(char *) "m_rawFlags", NULL
18983 };
18984
18985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18987 if (SWIG_arg_fail(1)) SWIG_fail;
18988 {
18989 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18990 if (SWIG_arg_fail(2)) SWIG_fail;
18991 }
18992 if (arg1) (arg1)->m_rawFlags = arg2;
18993
18994 Py_INCREF(Py_None); resultobj = Py_None;
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19002 PyObject *resultobj;
19003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19004 unsigned int result;
19005 PyObject * obj0 = 0 ;
19006 char *kwnames[] = {
19007 (char *) "self", NULL
19008 };
19009
19010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 result = (unsigned int) ((arg1)->m_rawFlags);
19014
19015 {
19016 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19017 }
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19025 PyObject *obj;
19026 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19027 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19028 Py_INCREF(obj);
19029 return Py_BuildValue((char *)"");
19030 }
19031 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj;
19033 wxSize const &arg1_defvalue = wxDefaultSize ;
19034 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19035 int arg2 = (int) 0 ;
19036 wxSizeEvent *result;
19037 wxSize temp1 ;
19038 PyObject * obj0 = 0 ;
19039 PyObject * obj1 = 0 ;
19040 char *kwnames[] = {
19041 (char *) "sz",(char *) "winid", NULL
19042 };
19043
19044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19045 if (obj0) {
19046 {
19047 arg1 = &temp1;
19048 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19049 }
19050 }
19051 if (obj1) {
19052 {
19053 arg2 = (int)(SWIG_As_int(obj1));
19054 if (SWIG_arg_fail(2)) SWIG_fail;
19055 }
19056 }
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19060
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19074 wxSize result;
19075 PyObject * obj0 = 0 ;
19076 char *kwnames[] = {
19077 (char *) "self", NULL
19078 };
19079
19080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19082 if (SWIG_arg_fail(1)) SWIG_fail;
19083 {
19084 PyThreadState* __tstate = wxPyBeginAllowThreads();
19085 result = ((wxSizeEvent const *)arg1)->GetSize();
19086
19087 wxPyEndAllowThreads(__tstate);
19088 if (PyErr_Occurred()) SWIG_fail;
19089 }
19090 {
19091 wxSize * resultptr;
19092 resultptr = new wxSize((wxSize &)(result));
19093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19094 }
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj;
19103 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19104 wxRect result;
19105 PyObject * obj0 = 0 ;
19106 char *kwnames[] = {
19107 (char *) "self", NULL
19108 };
19109
19110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19112 if (SWIG_arg_fail(1)) SWIG_fail;
19113 {
19114 PyThreadState* __tstate = wxPyBeginAllowThreads();
19115 result = ((wxSizeEvent const *)arg1)->GetRect();
19116
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 {
19121 wxRect * resultptr;
19122 resultptr = new wxRect((wxRect &)(result));
19123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19124 }
19125 return resultobj;
19126 fail:
19127 return NULL;
19128 }
19129
19130
19131 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19132 PyObject *resultobj;
19133 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19134 wxRect arg2 ;
19135 PyObject * obj0 = 0 ;
19136 PyObject * obj1 = 0 ;
19137 char *kwnames[] = {
19138 (char *) "self",(char *) "rect", NULL
19139 };
19140
19141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19143 if (SWIG_arg_fail(1)) SWIG_fail;
19144 {
19145 wxRect * argp;
19146 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19147 if (SWIG_arg_fail(2)) SWIG_fail;
19148 if (argp == NULL) {
19149 SWIG_null_ref("wxRect");
19150 }
19151 if (SWIG_arg_fail(2)) SWIG_fail;
19152 arg2 = *argp;
19153 }
19154 {
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 (arg1)->SetRect(arg2);
19157
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 Py_INCREF(Py_None); resultobj = Py_None;
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj;
19170 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19171 wxSize arg2 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 char *kwnames[] = {
19175 (char *) "self",(char *) "size", NULL
19176 };
19177
19178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19180 if (SWIG_arg_fail(1)) SWIG_fail;
19181 {
19182 wxSize * argp;
19183 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19184 if (SWIG_arg_fail(2)) SWIG_fail;
19185 if (argp == NULL) {
19186 SWIG_null_ref("wxSize");
19187 }
19188 if (SWIG_arg_fail(2)) SWIG_fail;
19189 arg2 = *argp;
19190 }
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 wxSizeEvent_SetSize(arg1,arg2);
19194
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 Py_INCREF(Py_None); resultobj = Py_None;
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19206 PyObject *resultobj;
19207 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19208 wxSize *arg2 = (wxSize *) 0 ;
19209 PyObject * obj0 = 0 ;
19210 PyObject * obj1 = 0 ;
19211 char *kwnames[] = {
19212 (char *) "self",(char *) "m_size", NULL
19213 };
19214
19215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19217 if (SWIG_arg_fail(1)) SWIG_fail;
19218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19219 if (SWIG_arg_fail(2)) SWIG_fail;
19220 if (arg1) (arg1)->m_size = *arg2;
19221
19222 Py_INCREF(Py_None); resultobj = Py_None;
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19230 PyObject *resultobj;
19231 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19232 wxSize *result;
19233 PyObject * obj0 = 0 ;
19234 char *kwnames[] = {
19235 (char *) "self", NULL
19236 };
19237
19238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19240 if (SWIG_arg_fail(1)) SWIG_fail;
19241 result = (wxSize *)& ((arg1)->m_size);
19242
19243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19251 PyObject *resultobj;
19252 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19253 wxRect *arg2 = (wxRect *) 0 ;
19254 PyObject * obj0 = 0 ;
19255 PyObject * obj1 = 0 ;
19256 char *kwnames[] = {
19257 (char *) "self",(char *) "m_rect", NULL
19258 };
19259
19260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19264 if (SWIG_arg_fail(2)) SWIG_fail;
19265 if (arg1) (arg1)->m_rect = *arg2;
19266
19267 Py_INCREF(Py_None); resultobj = Py_None;
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj;
19276 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19277 wxRect *result;
19278 PyObject * obj0 = 0 ;
19279 char *kwnames[] = {
19280 (char *) "self", NULL
19281 };
19282
19283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19285 if (SWIG_arg_fail(1)) SWIG_fail;
19286 result = (wxRect *)& ((arg1)->m_rect);
19287
19288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19296 PyObject *obj;
19297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19298 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19299 Py_INCREF(obj);
19300 return Py_BuildValue((char *)"");
19301 }
19302 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj;
19304 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19305 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19306 int arg2 = (int) 0 ;
19307 wxMoveEvent *result;
19308 wxPoint temp1 ;
19309 PyObject * obj0 = 0 ;
19310 PyObject * obj1 = 0 ;
19311 char *kwnames[] = {
19312 (char *) "pos",(char *) "winid", NULL
19313 };
19314
19315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19316 if (obj0) {
19317 {
19318 arg1 = &temp1;
19319 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19320 }
19321 }
19322 if (obj1) {
19323 {
19324 arg2 = (int)(SWIG_As_int(obj1));
19325 if (SWIG_arg_fail(2)) SWIG_fail;
19326 }
19327 }
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19331
19332 wxPyEndAllowThreads(__tstate);
19333 if (PyErr_Occurred()) SWIG_fail;
19334 }
19335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19343 PyObject *resultobj;
19344 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19345 wxPoint result;
19346 PyObject * obj0 = 0 ;
19347 char *kwnames[] = {
19348 (char *) "self", NULL
19349 };
19350
19351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19353 if (SWIG_arg_fail(1)) SWIG_fail;
19354 {
19355 PyThreadState* __tstate = wxPyBeginAllowThreads();
19356 result = ((wxMoveEvent const *)arg1)->GetPosition();
19357
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 {
19362 wxPoint * resultptr;
19363 resultptr = new wxPoint((wxPoint &)(result));
19364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19365 }
19366 return resultobj;
19367 fail:
19368 return NULL;
19369 }
19370
19371
19372 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19373 PyObject *resultobj;
19374 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19375 wxRect result;
19376 PyObject * obj0 = 0 ;
19377 char *kwnames[] = {
19378 (char *) "self", NULL
19379 };
19380
19381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19383 if (SWIG_arg_fail(1)) SWIG_fail;
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = ((wxMoveEvent const *)arg1)->GetRect();
19387
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 {
19392 wxRect * resultptr;
19393 resultptr = new wxRect((wxRect &)(result));
19394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj;
19404 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19405 wxRect *arg2 = 0 ;
19406 wxRect temp2 ;
19407 PyObject * obj0 = 0 ;
19408 PyObject * obj1 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "self",(char *) "rect", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19415 if (SWIG_arg_fail(1)) SWIG_fail;
19416 {
19417 arg2 = &temp2;
19418 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19419 }
19420 {
19421 PyThreadState* __tstate = wxPyBeginAllowThreads();
19422 (arg1)->SetRect((wxRect const &)*arg2);
19423
19424 wxPyEndAllowThreads(__tstate);
19425 if (PyErr_Occurred()) SWIG_fail;
19426 }
19427 Py_INCREF(Py_None); resultobj = Py_None;
19428 return resultobj;
19429 fail:
19430 return NULL;
19431 }
19432
19433
19434 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19435 PyObject *resultobj;
19436 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19437 wxPoint *arg2 = 0 ;
19438 wxPoint temp2 ;
19439 PyObject * obj0 = 0 ;
19440 PyObject * obj1 = 0 ;
19441 char *kwnames[] = {
19442 (char *) "self",(char *) "pos", NULL
19443 };
19444
19445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19447 if (SWIG_arg_fail(1)) SWIG_fail;
19448 {
19449 arg2 = &temp2;
19450 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19451 }
19452 {
19453 PyThreadState* __tstate = wxPyBeginAllowThreads();
19454 (arg1)->SetPosition((wxPoint const &)*arg2);
19455
19456 wxPyEndAllowThreads(__tstate);
19457 if (PyErr_Occurred()) SWIG_fail;
19458 }
19459 Py_INCREF(Py_None); resultobj = Py_None;
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19467 PyObject *obj;
19468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19469 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19470 Py_INCREF(obj);
19471 return Py_BuildValue((char *)"");
19472 }
19473 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19474 PyObject *resultobj;
19475 int arg1 = (int) 0 ;
19476 wxPaintEvent *result;
19477 PyObject * obj0 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "Id", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19483 if (obj0) {
19484 {
19485 arg1 = (int)(SWIG_As_int(obj0));
19486 if (SWIG_arg_fail(1)) SWIG_fail;
19487 }
19488 }
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19492
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19504 PyObject *obj;
19505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19506 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19507 Py_INCREF(obj);
19508 return Py_BuildValue((char *)"");
19509 }
19510 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj;
19512 int arg1 = (int) 0 ;
19513 wxNcPaintEvent *result;
19514 PyObject * obj0 = 0 ;
19515 char *kwnames[] = {
19516 (char *) "winid", NULL
19517 };
19518
19519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19520 if (obj0) {
19521 {
19522 arg1 = (int)(SWIG_As_int(obj0));
19523 if (SWIG_arg_fail(1)) SWIG_fail;
19524 }
19525 }
19526 {
19527 PyThreadState* __tstate = wxPyBeginAllowThreads();
19528 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19529
19530 wxPyEndAllowThreads(__tstate);
19531 if (PyErr_Occurred()) SWIG_fail;
19532 }
19533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19541 PyObject *obj;
19542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19543 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19544 Py_INCREF(obj);
19545 return Py_BuildValue((char *)"");
19546 }
19547 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj;
19549 int arg1 = (int) 0 ;
19550 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19551 wxEraseEvent *result;
19552 PyObject * obj0 = 0 ;
19553 PyObject * obj1 = 0 ;
19554 char *kwnames[] = {
19555 (char *) "Id",(char *) "dc", NULL
19556 };
19557
19558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19559 if (obj0) {
19560 {
19561 arg1 = (int)(SWIG_As_int(obj0));
19562 if (SWIG_arg_fail(1)) SWIG_fail;
19563 }
19564 }
19565 if (obj1) {
19566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19567 if (SWIG_arg_fail(2)) SWIG_fail;
19568 }
19569 {
19570 PyThreadState* __tstate = wxPyBeginAllowThreads();
19571 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19572
19573 wxPyEndAllowThreads(__tstate);
19574 if (PyErr_Occurred()) SWIG_fail;
19575 }
19576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19577 return resultobj;
19578 fail:
19579 return NULL;
19580 }
19581
19582
19583 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19584 PyObject *resultobj;
19585 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19586 wxDC *result;
19587 PyObject * obj0 = 0 ;
19588 char *kwnames[] = {
19589 (char *) "self", NULL
19590 };
19591
19592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19594 if (SWIG_arg_fail(1)) SWIG_fail;
19595 {
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19598
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 {
19603 resultobj = wxPyMake_wxObject(result, 0);
19604 }
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19612 PyObject *obj;
19613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19614 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19615 Py_INCREF(obj);
19616 return Py_BuildValue((char *)"");
19617 }
19618 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19619 PyObject *resultobj;
19620 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19621 int arg2 = (int) 0 ;
19622 wxFocusEvent *result;
19623 PyObject * obj0 = 0 ;
19624 PyObject * obj1 = 0 ;
19625 char *kwnames[] = {
19626 (char *) "type",(char *) "winid", NULL
19627 };
19628
19629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19630 if (obj0) {
19631 {
19632 arg1 = (wxEventType)(SWIG_As_int(obj0));
19633 if (SWIG_arg_fail(1)) SWIG_fail;
19634 }
19635 }
19636 if (obj1) {
19637 {
19638 arg2 = (int)(SWIG_As_int(obj1));
19639 if (SWIG_arg_fail(2)) SWIG_fail;
19640 }
19641 }
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19645
19646 wxPyEndAllowThreads(__tstate);
19647 if (PyErr_Occurred()) SWIG_fail;
19648 }
19649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19650 return resultobj;
19651 fail:
19652 return NULL;
19653 }
19654
19655
19656 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19657 PyObject *resultobj;
19658 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19659 wxWindow *result;
19660 PyObject * obj0 = 0 ;
19661 char *kwnames[] = {
19662 (char *) "self", NULL
19663 };
19664
19665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19667 if (SWIG_arg_fail(1)) SWIG_fail;
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19671
19672 wxPyEndAllowThreads(__tstate);
19673 if (PyErr_Occurred()) SWIG_fail;
19674 }
19675 {
19676 resultobj = wxPyMake_wxObject(result, 0);
19677 }
19678 return resultobj;
19679 fail:
19680 return NULL;
19681 }
19682
19683
19684 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19685 PyObject *resultobj;
19686 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19687 wxWindow *arg2 = (wxWindow *) 0 ;
19688 PyObject * obj0 = 0 ;
19689 PyObject * obj1 = 0 ;
19690 char *kwnames[] = {
19691 (char *) "self",(char *) "win", NULL
19692 };
19693
19694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19696 if (SWIG_arg_fail(1)) SWIG_fail;
19697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19698 if (SWIG_arg_fail(2)) SWIG_fail;
19699 {
19700 PyThreadState* __tstate = wxPyBeginAllowThreads();
19701 (arg1)->SetWindow(arg2);
19702
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 Py_INCREF(Py_None); resultobj = Py_None;
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19714 PyObject *obj;
19715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19716 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19717 Py_INCREF(obj);
19718 return Py_BuildValue((char *)"");
19719 }
19720 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19721 PyObject *resultobj;
19722 wxWindow *arg1 = (wxWindow *) NULL ;
19723 wxChildFocusEvent *result;
19724 PyObject * obj0 = 0 ;
19725 char *kwnames[] = {
19726 (char *) "win", NULL
19727 };
19728
19729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19730 if (obj0) {
19731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19732 if (SWIG_arg_fail(1)) SWIG_fail;
19733 }
19734 {
19735 PyThreadState* __tstate = wxPyBeginAllowThreads();
19736 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19737
19738 wxPyEndAllowThreads(__tstate);
19739 if (PyErr_Occurred()) SWIG_fail;
19740 }
19741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19742 return resultobj;
19743 fail:
19744 return NULL;
19745 }
19746
19747
19748 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19749 PyObject *resultobj;
19750 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19751 wxWindow *result;
19752 PyObject * obj0 = 0 ;
19753 char *kwnames[] = {
19754 (char *) "self", NULL
19755 };
19756
19757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19759 if (SWIG_arg_fail(1)) SWIG_fail;
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19763
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 {
19768 resultobj = wxPyMake_wxObject(result, 0);
19769 }
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19777 PyObject *obj;
19778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19779 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19780 Py_INCREF(obj);
19781 return Py_BuildValue((char *)"");
19782 }
19783 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj;
19785 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19786 bool arg2 = (bool) true ;
19787 int arg3 = (int) 0 ;
19788 wxActivateEvent *result;
19789 PyObject * obj0 = 0 ;
19790 PyObject * obj1 = 0 ;
19791 PyObject * obj2 = 0 ;
19792 char *kwnames[] = {
19793 (char *) "type",(char *) "active",(char *) "Id", NULL
19794 };
19795
19796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19797 if (obj0) {
19798 {
19799 arg1 = (wxEventType)(SWIG_As_int(obj0));
19800 if (SWIG_arg_fail(1)) SWIG_fail;
19801 }
19802 }
19803 if (obj1) {
19804 {
19805 arg2 = (bool)(SWIG_As_bool(obj1));
19806 if (SWIG_arg_fail(2)) SWIG_fail;
19807 }
19808 }
19809 if (obj2) {
19810 {
19811 arg3 = (int)(SWIG_As_int(obj2));
19812 if (SWIG_arg_fail(3)) SWIG_fail;
19813 }
19814 }
19815 {
19816 PyThreadState* __tstate = wxPyBeginAllowThreads();
19817 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19818
19819 wxPyEndAllowThreads(__tstate);
19820 if (PyErr_Occurred()) SWIG_fail;
19821 }
19822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19823 return resultobj;
19824 fail:
19825 return NULL;
19826 }
19827
19828
19829 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19830 PyObject *resultobj;
19831 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19832 bool result;
19833 PyObject * obj0 = 0 ;
19834 char *kwnames[] = {
19835 (char *) "self", NULL
19836 };
19837
19838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19840 if (SWIG_arg_fail(1)) SWIG_fail;
19841 {
19842 PyThreadState* __tstate = wxPyBeginAllowThreads();
19843 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19844
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 {
19849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19858 PyObject *obj;
19859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19860 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19861 Py_INCREF(obj);
19862 return Py_BuildValue((char *)"");
19863 }
19864 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19865 PyObject *resultobj;
19866 int arg1 = (int) 0 ;
19867 wxInitDialogEvent *result;
19868 PyObject * obj0 = 0 ;
19869 char *kwnames[] = {
19870 (char *) "Id", NULL
19871 };
19872
19873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19874 if (obj0) {
19875 {
19876 arg1 = (int)(SWIG_As_int(obj0));
19877 if (SWIG_arg_fail(1)) SWIG_fail;
19878 }
19879 }
19880 {
19881 PyThreadState* __tstate = wxPyBeginAllowThreads();
19882 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19883
19884 wxPyEndAllowThreads(__tstate);
19885 if (PyErr_Occurred()) SWIG_fail;
19886 }
19887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19888 return resultobj;
19889 fail:
19890 return NULL;
19891 }
19892
19893
19894 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19895 PyObject *obj;
19896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19897 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19898 Py_INCREF(obj);
19899 return Py_BuildValue((char *)"");
19900 }
19901 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19902 PyObject *resultobj;
19903 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19904 int arg2 = (int) 0 ;
19905 wxMenu *arg3 = (wxMenu *) NULL ;
19906 wxMenuEvent *result;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 PyObject * obj2 = 0 ;
19910 char *kwnames[] = {
19911 (char *) "type",(char *) "winid",(char *) "menu", NULL
19912 };
19913
19914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19915 if (obj0) {
19916 {
19917 arg1 = (wxEventType)(SWIG_As_int(obj0));
19918 if (SWIG_arg_fail(1)) SWIG_fail;
19919 }
19920 }
19921 if (obj1) {
19922 {
19923 arg2 = (int)(SWIG_As_int(obj1));
19924 if (SWIG_arg_fail(2)) SWIG_fail;
19925 }
19926 }
19927 if (obj2) {
19928 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(3)) SWIG_fail;
19930 }
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19934
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19946 PyObject *resultobj;
19947 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19948 int result;
19949 PyObject * obj0 = 0 ;
19950 char *kwnames[] = {
19951 (char *) "self", NULL
19952 };
19953
19954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19956 if (SWIG_arg_fail(1)) SWIG_fail;
19957 {
19958 PyThreadState* __tstate = wxPyBeginAllowThreads();
19959 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19960
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 {
19965 resultobj = SWIG_From_int((int)(result));
19966 }
19967 return resultobj;
19968 fail:
19969 return NULL;
19970 }
19971
19972
19973 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19974 PyObject *resultobj;
19975 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19976 bool result;
19977 PyObject * obj0 = 0 ;
19978 char *kwnames[] = {
19979 (char *) "self", NULL
19980 };
19981
19982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19984 if (SWIG_arg_fail(1)) SWIG_fail;
19985 {
19986 PyThreadState* __tstate = wxPyBeginAllowThreads();
19987 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19988
19989 wxPyEndAllowThreads(__tstate);
19990 if (PyErr_Occurred()) SWIG_fail;
19991 }
19992 {
19993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19994 }
19995 return resultobj;
19996 fail:
19997 return NULL;
19998 }
19999
20000
20001 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj;
20003 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20004 wxMenu *result;
20005 PyObject * obj0 = 0 ;
20006 char *kwnames[] = {
20007 (char *) "self", NULL
20008 };
20009
20010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20012 if (SWIG_arg_fail(1)) SWIG_fail;
20013 {
20014 PyThreadState* __tstate = wxPyBeginAllowThreads();
20015 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20016
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 {
20021 resultobj = wxPyMake_wxObject(result, 0);
20022 }
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20030 PyObject *obj;
20031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20032 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20033 Py_INCREF(obj);
20034 return Py_BuildValue((char *)"");
20035 }
20036 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20037 PyObject *resultobj;
20038 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20039 int arg2 = (int) 0 ;
20040 wxCloseEvent *result;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 char *kwnames[] = {
20044 (char *) "type",(char *) "winid", NULL
20045 };
20046
20047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20048 if (obj0) {
20049 {
20050 arg1 = (wxEventType)(SWIG_As_int(obj0));
20051 if (SWIG_arg_fail(1)) SWIG_fail;
20052 }
20053 }
20054 if (obj1) {
20055 {
20056 arg2 = (int)(SWIG_As_int(obj1));
20057 if (SWIG_arg_fail(2)) SWIG_fail;
20058 }
20059 }
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20063
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj;
20076 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20077 bool arg2 ;
20078 PyObject * obj0 = 0 ;
20079 PyObject * obj1 = 0 ;
20080 char *kwnames[] = {
20081 (char *) "self",(char *) "logOff", NULL
20082 };
20083
20084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20086 if (SWIG_arg_fail(1)) SWIG_fail;
20087 {
20088 arg2 = (bool)(SWIG_As_bool(obj1));
20089 if (SWIG_arg_fail(2)) SWIG_fail;
20090 }
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 (arg1)->SetLoggingOff(arg2);
20094
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 Py_INCREF(Py_None); resultobj = Py_None;
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20106 PyObject *resultobj;
20107 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20108 bool result;
20109 PyObject * obj0 = 0 ;
20110 char *kwnames[] = {
20111 (char *) "self", NULL
20112 };
20113
20114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20116 if (SWIG_arg_fail(1)) SWIG_fail;
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20120
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 {
20125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20126 }
20127 return resultobj;
20128 fail:
20129 return NULL;
20130 }
20131
20132
20133 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20134 PyObject *resultobj;
20135 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20136 bool arg2 = (bool) true ;
20137 PyObject * obj0 = 0 ;
20138 PyObject * obj1 = 0 ;
20139 char *kwnames[] = {
20140 (char *) "self",(char *) "veto", NULL
20141 };
20142
20143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20145 if (SWIG_arg_fail(1)) SWIG_fail;
20146 if (obj1) {
20147 {
20148 arg2 = (bool)(SWIG_As_bool(obj1));
20149 if (SWIG_arg_fail(2)) SWIG_fail;
20150 }
20151 }
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 (arg1)->Veto(arg2);
20155
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 Py_INCREF(Py_None); resultobj = Py_None;
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20169 bool arg2 ;
20170 PyObject * obj0 = 0 ;
20171 PyObject * obj1 = 0 ;
20172 char *kwnames[] = {
20173 (char *) "self",(char *) "canVeto", NULL
20174 };
20175
20176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20178 if (SWIG_arg_fail(1)) SWIG_fail;
20179 {
20180 arg2 = (bool)(SWIG_As_bool(obj1));
20181 if (SWIG_arg_fail(2)) SWIG_fail;
20182 }
20183 {
20184 PyThreadState* __tstate = wxPyBeginAllowThreads();
20185 (arg1)->SetCanVeto(arg2);
20186
20187 wxPyEndAllowThreads(__tstate);
20188 if (PyErr_Occurred()) SWIG_fail;
20189 }
20190 Py_INCREF(Py_None); resultobj = Py_None;
20191 return resultobj;
20192 fail:
20193 return NULL;
20194 }
20195
20196
20197 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20198 PyObject *resultobj;
20199 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20200 bool result;
20201 PyObject * obj0 = 0 ;
20202 char *kwnames[] = {
20203 (char *) "self", NULL
20204 };
20205
20206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20208 if (SWIG_arg_fail(1)) SWIG_fail;
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20212
20213 wxPyEndAllowThreads(__tstate);
20214 if (PyErr_Occurred()) SWIG_fail;
20215 }
20216 {
20217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20218 }
20219 return resultobj;
20220 fail:
20221 return NULL;
20222 }
20223
20224
20225 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj;
20227 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20228 bool result;
20229 PyObject * obj0 = 0 ;
20230 char *kwnames[] = {
20231 (char *) "self", NULL
20232 };
20233
20234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20236 if (SWIG_arg_fail(1)) SWIG_fail;
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20240
20241 wxPyEndAllowThreads(__tstate);
20242 if (PyErr_Occurred()) SWIG_fail;
20243 }
20244 {
20245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20246 }
20247 return resultobj;
20248 fail:
20249 return NULL;
20250 }
20251
20252
20253 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20254 PyObject *obj;
20255 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20256 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20257 Py_INCREF(obj);
20258 return Py_BuildValue((char *)"");
20259 }
20260 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20261 PyObject *resultobj;
20262 int arg1 = (int) 0 ;
20263 bool arg2 = (bool) false ;
20264 wxShowEvent *result;
20265 PyObject * obj0 = 0 ;
20266 PyObject * obj1 = 0 ;
20267 char *kwnames[] = {
20268 (char *) "winid",(char *) "show", NULL
20269 };
20270
20271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20272 if (obj0) {
20273 {
20274 arg1 = (int)(SWIG_As_int(obj0));
20275 if (SWIG_arg_fail(1)) SWIG_fail;
20276 }
20277 }
20278 if (obj1) {
20279 {
20280 arg2 = (bool)(SWIG_As_bool(obj1));
20281 if (SWIG_arg_fail(2)) SWIG_fail;
20282 }
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20287
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20301 bool arg2 ;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 char *kwnames[] = {
20305 (char *) "self",(char *) "show", NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20310 if (SWIG_arg_fail(1)) SWIG_fail;
20311 {
20312 arg2 = (bool)(SWIG_As_bool(obj1));
20313 if (SWIG_arg_fail(2)) SWIG_fail;
20314 }
20315 {
20316 PyThreadState* __tstate = wxPyBeginAllowThreads();
20317 (arg1)->SetShow(arg2);
20318
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 Py_INCREF(Py_None); resultobj = Py_None;
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20332 bool result;
20333 PyObject * obj0 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "self", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20340 if (SWIG_arg_fail(1)) SWIG_fail;
20341 {
20342 PyThreadState* __tstate = wxPyBeginAllowThreads();
20343 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20344
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 {
20349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20350 }
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20358 PyObject *obj;
20359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20360 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20361 Py_INCREF(obj);
20362 return Py_BuildValue((char *)"");
20363 }
20364 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj;
20366 int arg1 = (int) 0 ;
20367 bool arg2 = (bool) true ;
20368 wxIconizeEvent *result;
20369 PyObject * obj0 = 0 ;
20370 PyObject * obj1 = 0 ;
20371 char *kwnames[] = {
20372 (char *) "id",(char *) "iconized", NULL
20373 };
20374
20375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20376 if (obj0) {
20377 {
20378 arg1 = (int)(SWIG_As_int(obj0));
20379 if (SWIG_arg_fail(1)) SWIG_fail;
20380 }
20381 }
20382 if (obj1) {
20383 {
20384 arg2 = (bool)(SWIG_As_bool(obj1));
20385 if (SWIG_arg_fail(2)) SWIG_fail;
20386 }
20387 }
20388 {
20389 PyThreadState* __tstate = wxPyBeginAllowThreads();
20390 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20391
20392 wxPyEndAllowThreads(__tstate);
20393 if (PyErr_Occurred()) SWIG_fail;
20394 }
20395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20396 return resultobj;
20397 fail:
20398 return NULL;
20399 }
20400
20401
20402 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20403 PyObject *resultobj;
20404 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20405 bool result;
20406 PyObject * obj0 = 0 ;
20407 char *kwnames[] = {
20408 (char *) "self", NULL
20409 };
20410
20411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20413 if (SWIG_arg_fail(1)) SWIG_fail;
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = (bool)(arg1)->Iconized();
20417
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 {
20422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20423 }
20424 return resultobj;
20425 fail:
20426 return NULL;
20427 }
20428
20429
20430 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20431 PyObject *obj;
20432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20433 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20434 Py_INCREF(obj);
20435 return Py_BuildValue((char *)"");
20436 }
20437 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20438 PyObject *resultobj;
20439 int arg1 = (int) 0 ;
20440 wxMaximizeEvent *result;
20441 PyObject * obj0 = 0 ;
20442 char *kwnames[] = {
20443 (char *) "id", NULL
20444 };
20445
20446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20447 if (obj0) {
20448 {
20449 arg1 = (int)(SWIG_As_int(obj0));
20450 if (SWIG_arg_fail(1)) SWIG_fail;
20451 }
20452 }
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20456
20457 wxPyEndAllowThreads(__tstate);
20458 if (PyErr_Occurred()) SWIG_fail;
20459 }
20460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20468 PyObject *obj;
20469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20470 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20471 Py_INCREF(obj);
20472 return Py_BuildValue((char *)"");
20473 }
20474 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20477 wxPoint result;
20478 PyObject * obj0 = 0 ;
20479 char *kwnames[] = {
20480 (char *) "self", NULL
20481 };
20482
20483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20485 if (SWIG_arg_fail(1)) SWIG_fail;
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (arg1)->GetPosition();
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 {
20494 wxPoint * resultptr;
20495 resultptr = new wxPoint((wxPoint &)(result));
20496 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20497 }
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20505 PyObject *resultobj;
20506 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20507 int result;
20508 PyObject * obj0 = 0 ;
20509 char *kwnames[] = {
20510 (char *) "self", NULL
20511 };
20512
20513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20515 if (SWIG_arg_fail(1)) SWIG_fail;
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 result = (int)(arg1)->GetNumberOfFiles();
20519
20520 wxPyEndAllowThreads(__tstate);
20521 if (PyErr_Occurred()) SWIG_fail;
20522 }
20523 {
20524 resultobj = SWIG_From_int((int)(result));
20525 }
20526 return resultobj;
20527 fail:
20528 return NULL;
20529 }
20530
20531
20532 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20533 PyObject *resultobj;
20534 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20535 PyObject *result;
20536 PyObject * obj0 = 0 ;
20537 char *kwnames[] = {
20538 (char *) "self", NULL
20539 };
20540
20541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20543 if (SWIG_arg_fail(1)) SWIG_fail;
20544 {
20545 PyThreadState* __tstate = wxPyBeginAllowThreads();
20546 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20547
20548 wxPyEndAllowThreads(__tstate);
20549 if (PyErr_Occurred()) SWIG_fail;
20550 }
20551 resultobj = result;
20552 return resultobj;
20553 fail:
20554 return NULL;
20555 }
20556
20557
20558 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20559 PyObject *obj;
20560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20561 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20562 Py_INCREF(obj);
20563 return Py_BuildValue((char *)"");
20564 }
20565 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj;
20567 int arg1 = (int) 0 ;
20568 wxUpdateUIEvent *result;
20569 PyObject * obj0 = 0 ;
20570 char *kwnames[] = {
20571 (char *) "commandId", NULL
20572 };
20573
20574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20575 if (obj0) {
20576 {
20577 arg1 = (int)(SWIG_As_int(obj0));
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 }
20580 }
20581 {
20582 PyThreadState* __tstate = wxPyBeginAllowThreads();
20583 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20584
20585 wxPyEndAllowThreads(__tstate);
20586 if (PyErr_Occurred()) SWIG_fail;
20587 }
20588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20596 PyObject *resultobj;
20597 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20598 bool result;
20599 PyObject * obj0 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "self", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20606 if (SWIG_arg_fail(1)) SWIG_fail;
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20610
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 {
20615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20616 }
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20624 PyObject *resultobj;
20625 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20626 bool result;
20627 PyObject * obj0 = 0 ;
20628 char *kwnames[] = {
20629 (char *) "self", NULL
20630 };
20631
20632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20634 if (SWIG_arg_fail(1)) SWIG_fail;
20635 {
20636 PyThreadState* __tstate = wxPyBeginAllowThreads();
20637 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20638
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 {
20643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20644 }
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj;
20653 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20654 wxString result;
20655 PyObject * obj0 = 0 ;
20656 char *kwnames[] = {
20657 (char *) "self", NULL
20658 };
20659
20660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20662 if (SWIG_arg_fail(1)) SWIG_fail;
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20666
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 {
20671 #if wxUSE_UNICODE
20672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20673 #else
20674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20675 #endif
20676 }
20677 return resultobj;
20678 fail:
20679 return NULL;
20680 }
20681
20682
20683 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20684 PyObject *resultobj;
20685 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20686 bool result;
20687 PyObject * obj0 = 0 ;
20688 char *kwnames[] = {
20689 (char *) "self", NULL
20690 };
20691
20692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20694 if (SWIG_arg_fail(1)) SWIG_fail;
20695 {
20696 PyThreadState* __tstate = wxPyBeginAllowThreads();
20697 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20698
20699 wxPyEndAllowThreads(__tstate);
20700 if (PyErr_Occurred()) SWIG_fail;
20701 }
20702 {
20703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20704 }
20705 return resultobj;
20706 fail:
20707 return NULL;
20708 }
20709
20710
20711 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20712 PyObject *resultobj;
20713 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20714 bool result;
20715 PyObject * obj0 = 0 ;
20716 char *kwnames[] = {
20717 (char *) "self", NULL
20718 };
20719
20720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20722 if (SWIG_arg_fail(1)) SWIG_fail;
20723 {
20724 PyThreadState* __tstate = wxPyBeginAllowThreads();
20725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20726
20727 wxPyEndAllowThreads(__tstate);
20728 if (PyErr_Occurred()) SWIG_fail;
20729 }
20730 {
20731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20732 }
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20740 PyObject *resultobj;
20741 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20742 bool result;
20743 PyObject * obj0 = 0 ;
20744 char *kwnames[] = {
20745 (char *) "self", NULL
20746 };
20747
20748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20750 if (SWIG_arg_fail(1)) SWIG_fail;
20751 {
20752 PyThreadState* __tstate = wxPyBeginAllowThreads();
20753 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20754
20755 wxPyEndAllowThreads(__tstate);
20756 if (PyErr_Occurred()) SWIG_fail;
20757 }
20758 {
20759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20760 }
20761 return resultobj;
20762 fail:
20763 return NULL;
20764 }
20765
20766
20767 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj;
20769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20770 bool arg2 ;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 char *kwnames[] = {
20774 (char *) "self",(char *) "check", NULL
20775 };
20776
20777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20779 if (SWIG_arg_fail(1)) SWIG_fail;
20780 {
20781 arg2 = (bool)(SWIG_As_bool(obj1));
20782 if (SWIG_arg_fail(2)) SWIG_fail;
20783 }
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 (arg1)->Check(arg2);
20787
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 Py_INCREF(Py_None); resultobj = Py_None;
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj;
20800 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20801 bool arg2 ;
20802 PyObject * obj0 = 0 ;
20803 PyObject * obj1 = 0 ;
20804 char *kwnames[] = {
20805 (char *) "self",(char *) "enable", NULL
20806 };
20807
20808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20810 if (SWIG_arg_fail(1)) SWIG_fail;
20811 {
20812 arg2 = (bool)(SWIG_As_bool(obj1));
20813 if (SWIG_arg_fail(2)) SWIG_fail;
20814 }
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 (arg1)->Enable(arg2);
20818
20819 wxPyEndAllowThreads(__tstate);
20820 if (PyErr_Occurred()) SWIG_fail;
20821 }
20822 Py_INCREF(Py_None); resultobj = Py_None;
20823 return resultobj;
20824 fail:
20825 return NULL;
20826 }
20827
20828
20829 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20830 PyObject *resultobj;
20831 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20832 wxString *arg2 = 0 ;
20833 bool temp2 = false ;
20834 PyObject * obj0 = 0 ;
20835 PyObject * obj1 = 0 ;
20836 char *kwnames[] = {
20837 (char *) "self",(char *) "text", NULL
20838 };
20839
20840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20842 if (SWIG_arg_fail(1)) SWIG_fail;
20843 {
20844 arg2 = wxString_in_helper(obj1);
20845 if (arg2 == NULL) SWIG_fail;
20846 temp2 = true;
20847 }
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 (arg1)->SetText((wxString const &)*arg2);
20851
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 Py_INCREF(Py_None); resultobj = Py_None;
20856 {
20857 if (temp2)
20858 delete arg2;
20859 }
20860 return resultobj;
20861 fail:
20862 {
20863 if (temp2)
20864 delete arg2;
20865 }
20866 return NULL;
20867 }
20868
20869
20870 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20871 PyObject *resultobj;
20872 long arg1 ;
20873 PyObject * obj0 = 0 ;
20874 char *kwnames[] = {
20875 (char *) "updateInterval", NULL
20876 };
20877
20878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20879 {
20880 arg1 = (long)(SWIG_As_long(obj0));
20881 if (SWIG_arg_fail(1)) SWIG_fail;
20882 }
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 wxUpdateUIEvent::SetUpdateInterval(arg1);
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 Py_INCREF(Py_None); resultobj = Py_None;
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 long result;
20900 char *kwnames[] = {
20901 NULL
20902 };
20903
20904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20908
20909 wxPyEndAllowThreads(__tstate);
20910 if (PyErr_Occurred()) SWIG_fail;
20911 }
20912 {
20913 resultobj = SWIG_From_long((long)(result));
20914 }
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20922 PyObject *resultobj;
20923 wxWindow *arg1 = (wxWindow *) 0 ;
20924 bool result;
20925 PyObject * obj0 = 0 ;
20926 char *kwnames[] = {
20927 (char *) "win", NULL
20928 };
20929
20930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20932 if (SWIG_arg_fail(1)) SWIG_fail;
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20936
20937 wxPyEndAllowThreads(__tstate);
20938 if (PyErr_Occurred()) SWIG_fail;
20939 }
20940 {
20941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20942 }
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20950 PyObject *resultobj;
20951 char *kwnames[] = {
20952 NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 wxUpdateUIEvent::ResetUpdateTime();
20959
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 Py_INCREF(Py_None); resultobj = Py_None;
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxUpdateUIMode arg1 ;
20973 PyObject * obj0 = 0 ;
20974 char *kwnames[] = {
20975 (char *) "mode", NULL
20976 };
20977
20978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20979 {
20980 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 }
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20986
20987 wxPyEndAllowThreads(__tstate);
20988 if (PyErr_Occurred()) SWIG_fail;
20989 }
20990 Py_INCREF(Py_None); resultobj = Py_None;
20991 return resultobj;
20992 fail:
20993 return NULL;
20994 }
20995
20996
20997 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20998 PyObject *resultobj;
20999 wxUpdateUIMode result;
21000 char *kwnames[] = {
21001 NULL
21002 };
21003
21004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21008
21009 wxPyEndAllowThreads(__tstate);
21010 if (PyErr_Occurred()) SWIG_fail;
21011 }
21012 resultobj = SWIG_From_int((result));
21013 return resultobj;
21014 fail:
21015 return NULL;
21016 }
21017
21018
21019 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21020 PyObject *obj;
21021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21022 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21023 Py_INCREF(obj);
21024 return Py_BuildValue((char *)"");
21025 }
21026 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21027 PyObject *resultobj;
21028 wxSysColourChangedEvent *result;
21029 char *kwnames[] = {
21030 NULL
21031 };
21032
21033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21034 {
21035 PyThreadState* __tstate = wxPyBeginAllowThreads();
21036 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21037
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21049 PyObject *obj;
21050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21051 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21052 Py_INCREF(obj);
21053 return Py_BuildValue((char *)"");
21054 }
21055 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21056 PyObject *resultobj;
21057 int arg1 = (int) 0 ;
21058 wxWindow *arg2 = (wxWindow *) NULL ;
21059 wxMouseCaptureChangedEvent *result;
21060 PyObject * obj0 = 0 ;
21061 PyObject * obj1 = 0 ;
21062 char *kwnames[] = {
21063 (char *) "winid",(char *) "gainedCapture", NULL
21064 };
21065
21066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21067 if (obj0) {
21068 {
21069 arg1 = (int)(SWIG_As_int(obj0));
21070 if (SWIG_arg_fail(1)) SWIG_fail;
21071 }
21072 }
21073 if (obj1) {
21074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21075 if (SWIG_arg_fail(2)) SWIG_fail;
21076 }
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21080
21081 wxPyEndAllowThreads(__tstate);
21082 if (PyErr_Occurred()) SWIG_fail;
21083 }
21084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21085 return resultobj;
21086 fail:
21087 return NULL;
21088 }
21089
21090
21091 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21092 PyObject *resultobj;
21093 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21094 wxWindow *result;
21095 PyObject * obj0 = 0 ;
21096 char *kwnames[] = {
21097 (char *) "self", NULL
21098 };
21099
21100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21102 if (SWIG_arg_fail(1)) SWIG_fail;
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21106
21107 wxPyEndAllowThreads(__tstate);
21108 if (PyErr_Occurred()) SWIG_fail;
21109 }
21110 {
21111 resultobj = wxPyMake_wxObject(result, 0);
21112 }
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21120 PyObject *obj;
21121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21122 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21123 Py_INCREF(obj);
21124 return Py_BuildValue((char *)"");
21125 }
21126 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj;
21128 wxDisplayChangedEvent *result;
21129 char *kwnames[] = {
21130 NULL
21131 };
21132
21133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21137
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21149 PyObject *obj;
21150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21151 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21152 Py_INCREF(obj);
21153 return Py_BuildValue((char *)"");
21154 }
21155 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21156 PyObject *resultobj;
21157 int arg1 = (int) 0 ;
21158 wxPaletteChangedEvent *result;
21159 PyObject * obj0 = 0 ;
21160 char *kwnames[] = {
21161 (char *) "id", NULL
21162 };
21163
21164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21165 if (obj0) {
21166 {
21167 arg1 = (int)(SWIG_As_int(obj0));
21168 if (SWIG_arg_fail(1)) SWIG_fail;
21169 }
21170 }
21171 {
21172 PyThreadState* __tstate = wxPyBeginAllowThreads();
21173 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21174
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21186 PyObject *resultobj;
21187 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21188 wxWindow *arg2 = (wxWindow *) 0 ;
21189 PyObject * obj0 = 0 ;
21190 PyObject * obj1 = 0 ;
21191 char *kwnames[] = {
21192 (char *) "self",(char *) "win", NULL
21193 };
21194
21195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21197 if (SWIG_arg_fail(1)) SWIG_fail;
21198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21199 if (SWIG_arg_fail(2)) SWIG_fail;
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 (arg1)->SetChangedWindow(arg2);
21203
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 Py_INCREF(Py_None); resultobj = Py_None;
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21215 PyObject *resultobj;
21216 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21217 wxWindow *result;
21218 PyObject * obj0 = 0 ;
21219 char *kwnames[] = {
21220 (char *) "self", NULL
21221 };
21222
21223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21225 if (SWIG_arg_fail(1)) SWIG_fail;
21226 {
21227 PyThreadState* __tstate = wxPyBeginAllowThreads();
21228 result = (wxWindow *)(arg1)->GetChangedWindow();
21229
21230 wxPyEndAllowThreads(__tstate);
21231 if (PyErr_Occurred()) SWIG_fail;
21232 }
21233 {
21234 resultobj = wxPyMake_wxObject(result, 0);
21235 }
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21243 PyObject *obj;
21244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21245 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21246 Py_INCREF(obj);
21247 return Py_BuildValue((char *)"");
21248 }
21249 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21250 PyObject *resultobj;
21251 int arg1 = (int) 0 ;
21252 wxQueryNewPaletteEvent *result;
21253 PyObject * obj0 = 0 ;
21254 char *kwnames[] = {
21255 (char *) "winid", NULL
21256 };
21257
21258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21259 if (obj0) {
21260 {
21261 arg1 = (int)(SWIG_As_int(obj0));
21262 if (SWIG_arg_fail(1)) SWIG_fail;
21263 }
21264 }
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21280 PyObject *resultobj;
21281 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21282 bool arg2 ;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char *kwnames[] = {
21286 (char *) "self",(char *) "realized", NULL
21287 };
21288
21289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21291 if (SWIG_arg_fail(1)) SWIG_fail;
21292 {
21293 arg2 = (bool)(SWIG_As_bool(obj1));
21294 if (SWIG_arg_fail(2)) SWIG_fail;
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 (arg1)->SetPaletteRealized(arg2);
21299
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 Py_INCREF(Py_None); resultobj = Py_None;
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj;
21312 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21313 bool result;
21314 PyObject * obj0 = 0 ;
21315 char *kwnames[] = {
21316 (char *) "self", NULL
21317 };
21318
21319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21321 if (SWIG_arg_fail(1)) SWIG_fail;
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21325
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 {
21330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21331 }
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21339 PyObject *obj;
21340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21341 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21342 Py_INCREF(obj);
21343 return Py_BuildValue((char *)"");
21344 }
21345 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21346 PyObject *resultobj;
21347 wxNavigationKeyEvent *result;
21348 char *kwnames[] = {
21349 NULL
21350 };
21351
21352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21353 {
21354 PyThreadState* __tstate = wxPyBeginAllowThreads();
21355 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21356
21357 wxPyEndAllowThreads(__tstate);
21358 if (PyErr_Occurred()) SWIG_fail;
21359 }
21360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj;
21369 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21370 bool result;
21371 PyObject * obj0 = 0 ;
21372 char *kwnames[] = {
21373 (char *) "self", NULL
21374 };
21375
21376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21378 if (SWIG_arg_fail(1)) SWIG_fail;
21379 {
21380 PyThreadState* __tstate = wxPyBeginAllowThreads();
21381 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21382
21383 wxPyEndAllowThreads(__tstate);
21384 if (PyErr_Occurred()) SWIG_fail;
21385 }
21386 {
21387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21388 }
21389 return resultobj;
21390 fail:
21391 return NULL;
21392 }
21393
21394
21395 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21396 PyObject *resultobj;
21397 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21398 bool arg2 ;
21399 PyObject * obj0 = 0 ;
21400 PyObject * obj1 = 0 ;
21401 char *kwnames[] = {
21402 (char *) "self",(char *) "forward", NULL
21403 };
21404
21405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21407 if (SWIG_arg_fail(1)) SWIG_fail;
21408 {
21409 arg2 = (bool)(SWIG_As_bool(obj1));
21410 if (SWIG_arg_fail(2)) SWIG_fail;
21411 }
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 (arg1)->SetDirection(arg2);
21415
21416 wxPyEndAllowThreads(__tstate);
21417 if (PyErr_Occurred()) SWIG_fail;
21418 }
21419 Py_INCREF(Py_None); resultobj = Py_None;
21420 return resultobj;
21421 fail:
21422 return NULL;
21423 }
21424
21425
21426 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj;
21428 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21429 bool result;
21430 PyObject * obj0 = 0 ;
21431 char *kwnames[] = {
21432 (char *) "self", NULL
21433 };
21434
21435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21437 if (SWIG_arg_fail(1)) SWIG_fail;
21438 {
21439 PyThreadState* __tstate = wxPyBeginAllowThreads();
21440 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21441
21442 wxPyEndAllowThreads(__tstate);
21443 if (PyErr_Occurred()) SWIG_fail;
21444 }
21445 {
21446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21447 }
21448 return resultobj;
21449 fail:
21450 return NULL;
21451 }
21452
21453
21454 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21455 PyObject *resultobj;
21456 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21457 bool arg2 ;
21458 PyObject * obj0 = 0 ;
21459 PyObject * obj1 = 0 ;
21460 char *kwnames[] = {
21461 (char *) "self",(char *) "ischange", NULL
21462 };
21463
21464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21466 if (SWIG_arg_fail(1)) SWIG_fail;
21467 {
21468 arg2 = (bool)(SWIG_As_bool(obj1));
21469 if (SWIG_arg_fail(2)) SWIG_fail;
21470 }
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 (arg1)->SetWindowChange(arg2);
21474
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 Py_INCREF(Py_None); resultobj = Py_None;
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21486 PyObject *resultobj;
21487 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21488 bool result;
21489 PyObject * obj0 = 0 ;
21490 char *kwnames[] = {
21491 (char *) "self", NULL
21492 };
21493
21494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21496 if (SWIG_arg_fail(1)) SWIG_fail;
21497 {
21498 PyThreadState* __tstate = wxPyBeginAllowThreads();
21499 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21500
21501 wxPyEndAllowThreads(__tstate);
21502 if (PyErr_Occurred()) SWIG_fail;
21503 }
21504 {
21505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21506 }
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21514 PyObject *resultobj;
21515 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21516 bool arg2 ;
21517 PyObject * obj0 = 0 ;
21518 PyObject * obj1 = 0 ;
21519 char *kwnames[] = {
21520 (char *) "self",(char *) "bIs", NULL
21521 };
21522
21523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21525 if (SWIG_arg_fail(1)) SWIG_fail;
21526 {
21527 arg2 = (bool)(SWIG_As_bool(obj1));
21528 if (SWIG_arg_fail(2)) SWIG_fail;
21529 }
21530 {
21531 PyThreadState* __tstate = wxPyBeginAllowThreads();
21532 (arg1)->SetFromTab(arg2);
21533
21534 wxPyEndAllowThreads(__tstate);
21535 if (PyErr_Occurred()) SWIG_fail;
21536 }
21537 Py_INCREF(Py_None); resultobj = Py_None;
21538 return resultobj;
21539 fail:
21540 return NULL;
21541 }
21542
21543
21544 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21545 PyObject *resultobj;
21546 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21547 long arg2 ;
21548 PyObject * obj0 = 0 ;
21549 PyObject * obj1 = 0 ;
21550 char *kwnames[] = {
21551 (char *) "self",(char *) "flags", NULL
21552 };
21553
21554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21556 if (SWIG_arg_fail(1)) SWIG_fail;
21557 {
21558 arg2 = (long)(SWIG_As_long(obj1));
21559 if (SWIG_arg_fail(2)) SWIG_fail;
21560 }
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 (arg1)->SetFlags(arg2);
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 Py_INCREF(Py_None); resultobj = Py_None;
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21576 PyObject *resultobj;
21577 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21578 wxWindow *result;
21579 PyObject * obj0 = 0 ;
21580 char *kwnames[] = {
21581 (char *) "self", NULL
21582 };
21583
21584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21586 if (SWIG_arg_fail(1)) SWIG_fail;
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21590
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 {
21595 resultobj = wxPyMake_wxObject(result, 0);
21596 }
21597 return resultobj;
21598 fail:
21599 return NULL;
21600 }
21601
21602
21603 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21604 PyObject *resultobj;
21605 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21606 wxWindow *arg2 = (wxWindow *) 0 ;
21607 PyObject * obj0 = 0 ;
21608 PyObject * obj1 = 0 ;
21609 char *kwnames[] = {
21610 (char *) "self",(char *) "win", NULL
21611 };
21612
21613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21615 if (SWIG_arg_fail(1)) SWIG_fail;
21616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21617 if (SWIG_arg_fail(2)) SWIG_fail;
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 (arg1)->SetCurrentFocus(arg2);
21621
21622 wxPyEndAllowThreads(__tstate);
21623 if (PyErr_Occurred()) SWIG_fail;
21624 }
21625 Py_INCREF(Py_None); resultobj = Py_None;
21626 return resultobj;
21627 fail:
21628 return NULL;
21629 }
21630
21631
21632 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21633 PyObject *obj;
21634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21635 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21636 Py_INCREF(obj);
21637 return Py_BuildValue((char *)"");
21638 }
21639 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj;
21641 wxWindow *arg1 = (wxWindow *) NULL ;
21642 wxWindowCreateEvent *result;
21643 PyObject * obj0 = 0 ;
21644 char *kwnames[] = {
21645 (char *) "win", NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21649 if (obj0) {
21650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21651 if (SWIG_arg_fail(1)) SWIG_fail;
21652 }
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21656
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21670 wxWindow *result;
21671 PyObject * obj0 = 0 ;
21672 char *kwnames[] = {
21673 (char *) "self", NULL
21674 };
21675
21676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21678 if (SWIG_arg_fail(1)) SWIG_fail;
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21682
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 {
21687 resultobj = wxPyMake_wxObject(result, 0);
21688 }
21689 return resultobj;
21690 fail:
21691 return NULL;
21692 }
21693
21694
21695 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21696 PyObject *obj;
21697 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21698 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21699 Py_INCREF(obj);
21700 return Py_BuildValue((char *)"");
21701 }
21702 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21703 PyObject *resultobj;
21704 wxWindow *arg1 = (wxWindow *) NULL ;
21705 wxWindowDestroyEvent *result;
21706 PyObject * obj0 = 0 ;
21707 char *kwnames[] = {
21708 (char *) "win", NULL
21709 };
21710
21711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21712 if (obj0) {
21713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21714 if (SWIG_arg_fail(1)) SWIG_fail;
21715 }
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21731 PyObject *resultobj;
21732 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21733 wxWindow *result;
21734 PyObject * obj0 = 0 ;
21735 char *kwnames[] = {
21736 (char *) "self", NULL
21737 };
21738
21739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21741 if (SWIG_arg_fail(1)) SWIG_fail;
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21745
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
21749 {
21750 resultobj = wxPyMake_wxObject(result, 0);
21751 }
21752 return resultobj;
21753 fail:
21754 return NULL;
21755 }
21756
21757
21758 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21759 PyObject *obj;
21760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21761 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21762 Py_INCREF(obj);
21763 return Py_BuildValue((char *)"");
21764 }
21765 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21766 PyObject *resultobj;
21767 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21768 int arg2 = (int) 0 ;
21769 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21770 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21771 wxContextMenuEvent *result;
21772 wxPoint temp3 ;
21773 PyObject * obj0 = 0 ;
21774 PyObject * obj1 = 0 ;
21775 PyObject * obj2 = 0 ;
21776 char *kwnames[] = {
21777 (char *) "type",(char *) "winid",(char *) "pt", NULL
21778 };
21779
21780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21781 if (obj0) {
21782 {
21783 arg1 = (wxEventType)(SWIG_As_int(obj0));
21784 if (SWIG_arg_fail(1)) SWIG_fail;
21785 }
21786 }
21787 if (obj1) {
21788 {
21789 arg2 = (int)(SWIG_As_int(obj1));
21790 if (SWIG_arg_fail(2)) SWIG_fail;
21791 }
21792 }
21793 if (obj2) {
21794 {
21795 arg3 = &temp3;
21796 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21797 }
21798 }
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21802
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21814 PyObject *resultobj;
21815 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21816 wxPoint *result;
21817 PyObject * obj0 = 0 ;
21818 char *kwnames[] = {
21819 (char *) "self", NULL
21820 };
21821
21822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21824 if (SWIG_arg_fail(1)) SWIG_fail;
21825 {
21826 PyThreadState* __tstate = wxPyBeginAllowThreads();
21827 {
21828 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21829 result = (wxPoint *) &_result_ref;
21830 }
21831
21832 wxPyEndAllowThreads(__tstate);
21833 if (PyErr_Occurred()) SWIG_fail;
21834 }
21835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21836 return resultobj;
21837 fail:
21838 return NULL;
21839 }
21840
21841
21842 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21843 PyObject *resultobj;
21844 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21845 wxPoint *arg2 = 0 ;
21846 wxPoint temp2 ;
21847 PyObject * obj0 = 0 ;
21848 PyObject * obj1 = 0 ;
21849 char *kwnames[] = {
21850 (char *) "self",(char *) "pos", NULL
21851 };
21852
21853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21855 if (SWIG_arg_fail(1)) SWIG_fail;
21856 {
21857 arg2 = &temp2;
21858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21859 }
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 (arg1)->SetPosition((wxPoint const &)*arg2);
21863
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 Py_INCREF(Py_None); resultobj = Py_None;
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21875 PyObject *obj;
21876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21877 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21878 Py_INCREF(obj);
21879 return Py_BuildValue((char *)"");
21880 }
21881 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj;
21883 wxIdleEvent *result;
21884 char *kwnames[] = {
21885 NULL
21886 };
21887
21888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21889 {
21890 PyThreadState* __tstate = wxPyBeginAllowThreads();
21891 result = (wxIdleEvent *)new wxIdleEvent();
21892
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21904 PyObject *resultobj;
21905 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21906 bool arg2 = (bool) true ;
21907 PyObject * obj0 = 0 ;
21908 PyObject * obj1 = 0 ;
21909 char *kwnames[] = {
21910 (char *) "self",(char *) "needMore", NULL
21911 };
21912
21913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21915 if (SWIG_arg_fail(1)) SWIG_fail;
21916 if (obj1) {
21917 {
21918 arg2 = (bool)(SWIG_As_bool(obj1));
21919 if (SWIG_arg_fail(2)) SWIG_fail;
21920 }
21921 }
21922 {
21923 PyThreadState* __tstate = wxPyBeginAllowThreads();
21924 (arg1)->RequestMore(arg2);
21925
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 Py_INCREF(Py_None); resultobj = Py_None;
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21937 PyObject *resultobj;
21938 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21939 bool result;
21940 PyObject * obj0 = 0 ;
21941 char *kwnames[] = {
21942 (char *) "self", NULL
21943 };
21944
21945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21947 if (SWIG_arg_fail(1)) SWIG_fail;
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21951
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 {
21956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21957 }
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21965 PyObject *resultobj;
21966 wxIdleMode arg1 ;
21967 PyObject * obj0 = 0 ;
21968 char *kwnames[] = {
21969 (char *) "mode", NULL
21970 };
21971
21972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21973 {
21974 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21975 if (SWIG_arg_fail(1)) SWIG_fail;
21976 }
21977 {
21978 PyThreadState* __tstate = wxPyBeginAllowThreads();
21979 wxIdleEvent::SetMode((wxIdleMode )arg1);
21980
21981 wxPyEndAllowThreads(__tstate);
21982 if (PyErr_Occurred()) SWIG_fail;
21983 }
21984 Py_INCREF(Py_None); resultobj = Py_None;
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj;
21993 wxIdleMode result;
21994 char *kwnames[] = {
21995 NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (wxIdleMode)wxIdleEvent::GetMode();
22002
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 resultobj = SWIG_From_int((result));
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22014 PyObject *resultobj;
22015 wxWindow *arg1 = (wxWindow *) 0 ;
22016 bool result;
22017 PyObject * obj0 = 0 ;
22018 char *kwnames[] = {
22019 (char *) "win", NULL
22020 };
22021
22022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22024 if (SWIG_arg_fail(1)) SWIG_fail;
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 result = (bool)wxIdleEvent::CanSend(arg1);
22028
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 {
22033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22034 }
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22042 PyObject *obj;
22043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22044 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22045 Py_INCREF(obj);
22046 return Py_BuildValue((char *)"");
22047 }
22048 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj;
22050 int arg1 = (int) 0 ;
22051 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22052 wxPyEvent *result;
22053 PyObject * obj0 = 0 ;
22054 PyObject * obj1 = 0 ;
22055 char *kwnames[] = {
22056 (char *) "winid",(char *) "commandType", NULL
22057 };
22058
22059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22060 if (obj0) {
22061 {
22062 arg1 = (int)(SWIG_As_int(obj0));
22063 if (SWIG_arg_fail(1)) SWIG_fail;
22064 }
22065 }
22066 if (obj1) {
22067 {
22068 arg2 = (wxEventType)(SWIG_As_int(obj1));
22069 if (SWIG_arg_fail(2)) SWIG_fail;
22070 }
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22075
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22087 PyObject *resultobj;
22088 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22089 PyObject * obj0 = 0 ;
22090 char *kwnames[] = {
22091 (char *) "self", NULL
22092 };
22093
22094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22096 if (SWIG_arg_fail(1)) SWIG_fail;
22097 {
22098 PyThreadState* __tstate = wxPyBeginAllowThreads();
22099 delete arg1;
22100
22101 wxPyEndAllowThreads(__tstate);
22102 if (PyErr_Occurred()) SWIG_fail;
22103 }
22104 Py_INCREF(Py_None); resultobj = Py_None;
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj;
22113 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22114 PyObject *arg2 = (PyObject *) 0 ;
22115 PyObject * obj0 = 0 ;
22116 PyObject * obj1 = 0 ;
22117 char *kwnames[] = {
22118 (char *) "self",(char *) "self", NULL
22119 };
22120
22121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22123 if (SWIG_arg_fail(1)) SWIG_fail;
22124 arg2 = obj1;
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 (arg1)->SetSelf(arg2);
22128
22129 wxPyEndAllowThreads(__tstate);
22130 if (PyErr_Occurred()) SWIG_fail;
22131 }
22132 Py_INCREF(Py_None); resultobj = Py_None;
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj;
22141 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22142 PyObject *result;
22143 PyObject * obj0 = 0 ;
22144 char *kwnames[] = {
22145 (char *) "self", NULL
22146 };
22147
22148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(1)) SWIG_fail;
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (PyObject *)(arg1)->GetSelf();
22154
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = result;
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22166 PyObject *obj;
22167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22168 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22169 Py_INCREF(obj);
22170 return Py_BuildValue((char *)"");
22171 }
22172 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22173 PyObject *resultobj;
22174 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22175 int arg2 = (int) 0 ;
22176 wxPyCommandEvent *result;
22177 PyObject * obj0 = 0 ;
22178 PyObject * obj1 = 0 ;
22179 char *kwnames[] = {
22180 (char *) "commandType",(char *) "id", NULL
22181 };
22182
22183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22184 if (obj0) {
22185 {
22186 arg1 = (wxEventType)(SWIG_As_int(obj0));
22187 if (SWIG_arg_fail(1)) SWIG_fail;
22188 }
22189 }
22190 if (obj1) {
22191 {
22192 arg2 = (int)(SWIG_As_int(obj1));
22193 if (SWIG_arg_fail(2)) SWIG_fail;
22194 }
22195 }
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22199
22200 wxPyEndAllowThreads(__tstate);
22201 if (PyErr_Occurred()) SWIG_fail;
22202 }
22203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22211 PyObject *resultobj;
22212 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22213 PyObject * obj0 = 0 ;
22214 char *kwnames[] = {
22215 (char *) "self", NULL
22216 };
22217
22218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22220 if (SWIG_arg_fail(1)) SWIG_fail;
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 delete arg1;
22224
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 Py_INCREF(Py_None); resultobj = Py_None;
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22236 PyObject *resultobj;
22237 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22238 PyObject *arg2 = (PyObject *) 0 ;
22239 PyObject * obj0 = 0 ;
22240 PyObject * obj1 = 0 ;
22241 char *kwnames[] = {
22242 (char *) "self",(char *) "self", NULL
22243 };
22244
22245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22247 if (SWIG_arg_fail(1)) SWIG_fail;
22248 arg2 = obj1;
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 (arg1)->SetSelf(arg2);
22252
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 Py_INCREF(Py_None); resultobj = Py_None;
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj;
22265 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22266 PyObject *result;
22267 PyObject * obj0 = 0 ;
22268 char *kwnames[] = {
22269 (char *) "self", NULL
22270 };
22271
22272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22274 if (SWIG_arg_fail(1)) SWIG_fail;
22275 {
22276 PyThreadState* __tstate = wxPyBeginAllowThreads();
22277 result = (PyObject *)(arg1)->GetSelf();
22278
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 resultobj = result;
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22290 PyObject *obj;
22291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22292 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22293 Py_INCREF(obj);
22294 return Py_BuildValue((char *)"");
22295 }
22296 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22297 PyObject *resultobj;
22298 wxWindow *arg1 = (wxWindow *) 0 ;
22299 wxDateTime *arg2 = 0 ;
22300 wxEventType arg3 ;
22301 wxDateEvent *result;
22302 PyObject * obj0 = 0 ;
22303 PyObject * obj1 = 0 ;
22304 PyObject * obj2 = 0 ;
22305 char *kwnames[] = {
22306 (char *) "win",(char *) "dt",(char *) "type", NULL
22307 };
22308
22309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22311 if (SWIG_arg_fail(1)) SWIG_fail;
22312 {
22313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(2)) SWIG_fail;
22315 if (arg2 == NULL) {
22316 SWIG_null_ref("wxDateTime");
22317 }
22318 if (SWIG_arg_fail(2)) SWIG_fail;
22319 }
22320 {
22321 arg3 = (wxEventType)(SWIG_As_int(obj2));
22322 if (SWIG_arg_fail(3)) SWIG_fail;
22323 }
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22327
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj;
22340 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22341 wxDateTime *result;
22342 PyObject * obj0 = 0 ;
22343 char *kwnames[] = {
22344 (char *) "self", NULL
22345 };
22346
22347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22349 if (SWIG_arg_fail(1)) SWIG_fail;
22350 {
22351 PyThreadState* __tstate = wxPyBeginAllowThreads();
22352 {
22353 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22354 result = (wxDateTime *) &_result_ref;
22355 }
22356
22357 wxPyEndAllowThreads(__tstate);
22358 if (PyErr_Occurred()) SWIG_fail;
22359 }
22360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22368 PyObject *resultobj;
22369 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22370 wxDateTime *arg2 = 0 ;
22371 PyObject * obj0 = 0 ;
22372 PyObject * obj1 = 0 ;
22373 char *kwnames[] = {
22374 (char *) "self",(char *) "date", NULL
22375 };
22376
22377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22379 if (SWIG_arg_fail(1)) SWIG_fail;
22380 {
22381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22382 if (SWIG_arg_fail(2)) SWIG_fail;
22383 if (arg2 == NULL) {
22384 SWIG_null_ref("wxDateTime");
22385 }
22386 if (SWIG_arg_fail(2)) SWIG_fail;
22387 }
22388 {
22389 PyThreadState* __tstate = wxPyBeginAllowThreads();
22390 (arg1)->SetDate((wxDateTime const &)*arg2);
22391
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 Py_INCREF(Py_None); resultobj = Py_None;
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22403 PyObject *obj;
22404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22405 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22406 Py_INCREF(obj);
22407 return Py_BuildValue((char *)"");
22408 }
22409 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22410 PyObject *resultobj;
22411 wxPyApp *result;
22412 char *kwnames[] = {
22413 NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = (wxPyApp *)new_wxPyApp();
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj;
22433 wxPyApp *arg1 = (wxPyApp *) 0 ;
22434 PyObject * obj0 = 0 ;
22435 char *kwnames[] = {
22436 (char *) "self", NULL
22437 };
22438
22439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22441 if (SWIG_arg_fail(1)) SWIG_fail;
22442 {
22443 PyThreadState* __tstate = wxPyBeginAllowThreads();
22444 delete arg1;
22445
22446 wxPyEndAllowThreads(__tstate);
22447 if (PyErr_Occurred()) SWIG_fail;
22448 }
22449 Py_INCREF(Py_None); resultobj = Py_None;
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22457 PyObject *resultobj;
22458 wxPyApp *arg1 = (wxPyApp *) 0 ;
22459 PyObject *arg2 = (PyObject *) 0 ;
22460 PyObject *arg3 = (PyObject *) 0 ;
22461 PyObject * obj0 = 0 ;
22462 PyObject * obj1 = 0 ;
22463 PyObject * obj2 = 0 ;
22464 char *kwnames[] = {
22465 (char *) "self",(char *) "self",(char *) "_class", NULL
22466 };
22467
22468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22470 if (SWIG_arg_fail(1)) SWIG_fail;
22471 arg2 = obj1;
22472 arg3 = obj2;
22473 {
22474 PyThreadState* __tstate = wxPyBeginAllowThreads();
22475 (arg1)->_setCallbackInfo(arg2,arg3);
22476
22477 wxPyEndAllowThreads(__tstate);
22478 if (PyErr_Occurred()) SWIG_fail;
22479 }
22480 Py_INCREF(Py_None); resultobj = Py_None;
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22488 PyObject *resultobj;
22489 wxPyApp *arg1 = (wxPyApp *) 0 ;
22490 wxString result;
22491 PyObject * obj0 = 0 ;
22492 char *kwnames[] = {
22493 (char *) "self", NULL
22494 };
22495
22496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22498 if (SWIG_arg_fail(1)) SWIG_fail;
22499 {
22500 PyThreadState* __tstate = wxPyBeginAllowThreads();
22501 result = ((wxPyApp const *)arg1)->GetAppName();
22502
22503 wxPyEndAllowThreads(__tstate);
22504 if (PyErr_Occurred()) SWIG_fail;
22505 }
22506 {
22507 #if wxUSE_UNICODE
22508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22509 #else
22510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22511 #endif
22512 }
22513 return resultobj;
22514 fail:
22515 return NULL;
22516 }
22517
22518
22519 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22520 PyObject *resultobj;
22521 wxPyApp *arg1 = (wxPyApp *) 0 ;
22522 wxString *arg2 = 0 ;
22523 bool temp2 = false ;
22524 PyObject * obj0 = 0 ;
22525 PyObject * obj1 = 0 ;
22526 char *kwnames[] = {
22527 (char *) "self",(char *) "name", NULL
22528 };
22529
22530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22532 if (SWIG_arg_fail(1)) SWIG_fail;
22533 {
22534 arg2 = wxString_in_helper(obj1);
22535 if (arg2 == NULL) SWIG_fail;
22536 temp2 = true;
22537 }
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 (arg1)->SetAppName((wxString const &)*arg2);
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 Py_INCREF(Py_None); resultobj = Py_None;
22546 {
22547 if (temp2)
22548 delete arg2;
22549 }
22550 return resultobj;
22551 fail:
22552 {
22553 if (temp2)
22554 delete arg2;
22555 }
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxPyApp *arg1 = (wxPyApp *) 0 ;
22563 wxString result;
22564 PyObject * obj0 = 0 ;
22565 char *kwnames[] = {
22566 (char *) "self", NULL
22567 };
22568
22569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",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 = ((wxPyApp const *)arg1)->GetClassName();
22575
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 {
22580 #if wxUSE_UNICODE
22581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22582 #else
22583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22584 #endif
22585 }
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22593 PyObject *resultobj;
22594 wxPyApp *arg1 = (wxPyApp *) 0 ;
22595 wxString *arg2 = 0 ;
22596 bool temp2 = false ;
22597 PyObject * obj0 = 0 ;
22598 PyObject * obj1 = 0 ;
22599 char *kwnames[] = {
22600 (char *) "self",(char *) "name", NULL
22601 };
22602
22603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22605 if (SWIG_arg_fail(1)) SWIG_fail;
22606 {
22607 arg2 = wxString_in_helper(obj1);
22608 if (arg2 == NULL) SWIG_fail;
22609 temp2 = true;
22610 }
22611 {
22612 PyThreadState* __tstate = wxPyBeginAllowThreads();
22613 (arg1)->SetClassName((wxString const &)*arg2);
22614
22615 wxPyEndAllowThreads(__tstate);
22616 if (PyErr_Occurred()) SWIG_fail;
22617 }
22618 Py_INCREF(Py_None); resultobj = Py_None;
22619 {
22620 if (temp2)
22621 delete arg2;
22622 }
22623 return resultobj;
22624 fail:
22625 {
22626 if (temp2)
22627 delete arg2;
22628 }
22629 return NULL;
22630 }
22631
22632
22633 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj;
22635 wxPyApp *arg1 = (wxPyApp *) 0 ;
22636 wxString *result;
22637 PyObject * obj0 = 0 ;
22638 char *kwnames[] = {
22639 (char *) "self", NULL
22640 };
22641
22642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22644 if (SWIG_arg_fail(1)) SWIG_fail;
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 {
22648 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22649 result = (wxString *) &_result_ref;
22650 }
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 {
22656 #if wxUSE_UNICODE
22657 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22658 #else
22659 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22660 #endif
22661 }
22662 return resultobj;
22663 fail:
22664 return NULL;
22665 }
22666
22667
22668 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22669 PyObject *resultobj;
22670 wxPyApp *arg1 = (wxPyApp *) 0 ;
22671 wxString *arg2 = 0 ;
22672 bool temp2 = false ;
22673 PyObject * obj0 = 0 ;
22674 PyObject * obj1 = 0 ;
22675 char *kwnames[] = {
22676 (char *) "self",(char *) "name", NULL
22677 };
22678
22679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22681 if (SWIG_arg_fail(1)) SWIG_fail;
22682 {
22683 arg2 = wxString_in_helper(obj1);
22684 if (arg2 == NULL) SWIG_fail;
22685 temp2 = true;
22686 }
22687 {
22688 PyThreadState* __tstate = wxPyBeginAllowThreads();
22689 (arg1)->SetVendorName((wxString const &)*arg2);
22690
22691 wxPyEndAllowThreads(__tstate);
22692 if (PyErr_Occurred()) SWIG_fail;
22693 }
22694 Py_INCREF(Py_None); resultobj = Py_None;
22695 {
22696 if (temp2)
22697 delete arg2;
22698 }
22699 return resultobj;
22700 fail:
22701 {
22702 if (temp2)
22703 delete arg2;
22704 }
22705 return NULL;
22706 }
22707
22708
22709 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22710 PyObject *resultobj;
22711 wxPyApp *arg1 = (wxPyApp *) 0 ;
22712 wxAppTraits *result;
22713 PyObject * obj0 = 0 ;
22714 char *kwnames[] = {
22715 (char *) "self", NULL
22716 };
22717
22718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22720 if (SWIG_arg_fail(1)) SWIG_fail;
22721 {
22722 PyThreadState* __tstate = wxPyBeginAllowThreads();
22723 result = (wxAppTraits *)(arg1)->GetTraits();
22724
22725 wxPyEndAllowThreads(__tstate);
22726 if (PyErr_Occurred()) SWIG_fail;
22727 }
22728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22729 return resultobj;
22730 fail:
22731 return NULL;
22732 }
22733
22734
22735 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj;
22737 wxPyApp *arg1 = (wxPyApp *) 0 ;
22738 PyObject * obj0 = 0 ;
22739 char *kwnames[] = {
22740 (char *) "self", NULL
22741 };
22742
22743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22745 if (SWIG_arg_fail(1)) SWIG_fail;
22746 {
22747 PyThreadState* __tstate = wxPyBeginAllowThreads();
22748 (arg1)->ProcessPendingEvents();
22749
22750 wxPyEndAllowThreads(__tstate);
22751 if (PyErr_Occurred()) SWIG_fail;
22752 }
22753 Py_INCREF(Py_None); resultobj = Py_None;
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22761 PyObject *resultobj;
22762 wxPyApp *arg1 = (wxPyApp *) 0 ;
22763 bool arg2 = (bool) false ;
22764 bool result;
22765 PyObject * obj0 = 0 ;
22766 PyObject * obj1 = 0 ;
22767 char *kwnames[] = {
22768 (char *) "self",(char *) "onlyIfNeeded", NULL
22769 };
22770
22771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22773 if (SWIG_arg_fail(1)) SWIG_fail;
22774 if (obj1) {
22775 {
22776 arg2 = (bool)(SWIG_As_bool(obj1));
22777 if (SWIG_arg_fail(2)) SWIG_fail;
22778 }
22779 }
22780 {
22781 PyThreadState* __tstate = wxPyBeginAllowThreads();
22782 result = (bool)(arg1)->Yield(arg2);
22783
22784 wxPyEndAllowThreads(__tstate);
22785 if (PyErr_Occurred()) SWIG_fail;
22786 }
22787 {
22788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22789 }
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj;
22798 wxPyApp *arg1 = (wxPyApp *) 0 ;
22799 PyObject * obj0 = 0 ;
22800 char *kwnames[] = {
22801 (char *) "self", NULL
22802 };
22803
22804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22806 if (SWIG_arg_fail(1)) SWIG_fail;
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 (arg1)->WakeUpIdle();
22810
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 Py_INCREF(Py_None); resultobj = Py_None;
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj;
22823 bool result;
22824 char *kwnames[] = {
22825 NULL
22826 };
22827
22828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22829 {
22830 PyThreadState* __tstate = wxPyBeginAllowThreads();
22831 result = (bool)wxPyApp::IsMainLoopRunning();
22832
22833 wxPyEndAllowThreads(__tstate);
22834 if (PyErr_Occurred()) SWIG_fail;
22835 }
22836 {
22837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22838 }
22839 return resultobj;
22840 fail:
22841 return NULL;
22842 }
22843
22844
22845 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22846 PyObject *resultobj;
22847 wxPyApp *arg1 = (wxPyApp *) 0 ;
22848 int result;
22849 PyObject * obj0 = 0 ;
22850 char *kwnames[] = {
22851 (char *) "self", NULL
22852 };
22853
22854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22856 if (SWIG_arg_fail(1)) SWIG_fail;
22857 {
22858 PyThreadState* __tstate = wxPyBeginAllowThreads();
22859 result = (int)(arg1)->MainLoop();
22860
22861 wxPyEndAllowThreads(__tstate);
22862 if (PyErr_Occurred()) SWIG_fail;
22863 }
22864 {
22865 resultobj = SWIG_From_int((int)(result));
22866 }
22867 return resultobj;
22868 fail:
22869 return NULL;
22870 }
22871
22872
22873 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22874 PyObject *resultobj;
22875 wxPyApp *arg1 = (wxPyApp *) 0 ;
22876 PyObject * obj0 = 0 ;
22877 char *kwnames[] = {
22878 (char *) "self", NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(1)) SWIG_fail;
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 (arg1)->Exit();
22887
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 Py_INCREF(Py_None); resultobj = Py_None;
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj;
22900 wxPyApp *arg1 = (wxPyApp *) 0 ;
22901 PyObject * obj0 = 0 ;
22902 char *kwnames[] = {
22903 (char *) "self", NULL
22904 };
22905
22906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 {
22910 PyThreadState* __tstate = wxPyBeginAllowThreads();
22911 (arg1)->ExitMainLoop();
22912
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 Py_INCREF(Py_None); resultobj = Py_None;
22917 return resultobj;
22918 fail:
22919 return NULL;
22920 }
22921
22922
22923 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22924 PyObject *resultobj;
22925 wxPyApp *arg1 = (wxPyApp *) 0 ;
22926 bool result;
22927 PyObject * obj0 = 0 ;
22928 char *kwnames[] = {
22929 (char *) "self", NULL
22930 };
22931
22932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22934 if (SWIG_arg_fail(1)) SWIG_fail;
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = (bool)(arg1)->Pending();
22938
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 {
22943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22944 }
22945 return resultobj;
22946 fail:
22947 return NULL;
22948 }
22949
22950
22951 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22952 PyObject *resultobj;
22953 wxPyApp *arg1 = (wxPyApp *) 0 ;
22954 bool result;
22955 PyObject * obj0 = 0 ;
22956 char *kwnames[] = {
22957 (char *) "self", NULL
22958 };
22959
22960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22962 if (SWIG_arg_fail(1)) SWIG_fail;
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 result = (bool)(arg1)->Dispatch();
22966
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 {
22971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22972 }
22973 return resultobj;
22974 fail:
22975 return NULL;
22976 }
22977
22978
22979 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22980 PyObject *resultobj;
22981 wxPyApp *arg1 = (wxPyApp *) 0 ;
22982 bool result;
22983 PyObject * obj0 = 0 ;
22984 char *kwnames[] = {
22985 (char *) "self", NULL
22986 };
22987
22988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22990 if (SWIG_arg_fail(1)) SWIG_fail;
22991 {
22992 PyThreadState* __tstate = wxPyBeginAllowThreads();
22993 result = (bool)(arg1)->ProcessIdle();
22994
22995 wxPyEndAllowThreads(__tstate);
22996 if (PyErr_Occurred()) SWIG_fail;
22997 }
22998 {
22999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23000 }
23001 return resultobj;
23002 fail:
23003 return NULL;
23004 }
23005
23006
23007 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23008 PyObject *resultobj;
23009 wxPyApp *arg1 = (wxPyApp *) 0 ;
23010 wxWindow *arg2 = (wxWindow *) 0 ;
23011 wxIdleEvent *arg3 = 0 ;
23012 bool result;
23013 PyObject * obj0 = 0 ;
23014 PyObject * obj1 = 0 ;
23015 PyObject * obj2 = 0 ;
23016 char *kwnames[] = {
23017 (char *) "self",(char *) "win",(char *) "event", NULL
23018 };
23019
23020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23022 if (SWIG_arg_fail(1)) SWIG_fail;
23023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23024 if (SWIG_arg_fail(2)) SWIG_fail;
23025 {
23026 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23027 if (SWIG_arg_fail(3)) SWIG_fail;
23028 if (arg3 == NULL) {
23029 SWIG_null_ref("wxIdleEvent");
23030 }
23031 if (SWIG_arg_fail(3)) SWIG_fail;
23032 }
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23036
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 {
23041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23042 }
23043 return resultobj;
23044 fail:
23045 return NULL;
23046 }
23047
23048
23049 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23050 PyObject *resultobj;
23051 wxPyApp *arg1 = (wxPyApp *) 0 ;
23052 bool result;
23053 PyObject * obj0 = 0 ;
23054 char *kwnames[] = {
23055 (char *) "self", NULL
23056 };
23057
23058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23060 if (SWIG_arg_fail(1)) SWIG_fail;
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 result = (bool)((wxPyApp const *)arg1)->IsActive();
23064
23065 wxPyEndAllowThreads(__tstate);
23066 if (PyErr_Occurred()) SWIG_fail;
23067 }
23068 {
23069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23070 }
23071 return resultobj;
23072 fail:
23073 return NULL;
23074 }
23075
23076
23077 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23078 PyObject *resultobj;
23079 wxPyApp *arg1 = (wxPyApp *) 0 ;
23080 wxWindow *arg2 = (wxWindow *) 0 ;
23081 PyObject * obj0 = 0 ;
23082 PyObject * obj1 = 0 ;
23083 char *kwnames[] = {
23084 (char *) "self",(char *) "win", NULL
23085 };
23086
23087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(1)) SWIG_fail;
23090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23091 if (SWIG_arg_fail(2)) SWIG_fail;
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 (arg1)->SetTopWindow(arg2);
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 Py_INCREF(Py_None); resultobj = Py_None;
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj;
23108 wxPyApp *arg1 = (wxPyApp *) 0 ;
23109 wxWindow *result;
23110 PyObject * obj0 = 0 ;
23111 char *kwnames[] = {
23112 (char *) "self", NULL
23113 };
23114
23115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23117 if (SWIG_arg_fail(1)) SWIG_fail;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 {
23126 resultobj = wxPyMake_wxObject(result, 0);
23127 }
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj;
23136 wxPyApp *arg1 = (wxPyApp *) 0 ;
23137 bool arg2 ;
23138 PyObject * obj0 = 0 ;
23139 PyObject * obj1 = 0 ;
23140 char *kwnames[] = {
23141 (char *) "self",(char *) "flag", NULL
23142 };
23143
23144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23146 if (SWIG_arg_fail(1)) SWIG_fail;
23147 {
23148 arg2 = (bool)(SWIG_As_bool(obj1));
23149 if (SWIG_arg_fail(2)) SWIG_fail;
23150 }
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 (arg1)->SetExitOnFrameDelete(arg2);
23154
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 Py_INCREF(Py_None); resultobj = Py_None;
23159 return resultobj;
23160 fail:
23161 return NULL;
23162 }
23163
23164
23165 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23166 PyObject *resultobj;
23167 wxPyApp *arg1 = (wxPyApp *) 0 ;
23168 bool result;
23169 PyObject * obj0 = 0 ;
23170 char *kwnames[] = {
23171 (char *) "self", NULL
23172 };
23173
23174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23176 if (SWIG_arg_fail(1)) SWIG_fail;
23177 {
23178 PyThreadState* __tstate = wxPyBeginAllowThreads();
23179 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23180
23181 wxPyEndAllowThreads(__tstate);
23182 if (PyErr_Occurred()) SWIG_fail;
23183 }
23184 {
23185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23186 }
23187 return resultobj;
23188 fail:
23189 return NULL;
23190 }
23191
23192
23193 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23194 PyObject *resultobj;
23195 wxPyApp *arg1 = (wxPyApp *) 0 ;
23196 bool arg2 ;
23197 PyObject * obj0 = 0 ;
23198 PyObject * obj1 = 0 ;
23199 char *kwnames[] = {
23200 (char *) "self",(char *) "flag", NULL
23201 };
23202
23203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23205 if (SWIG_arg_fail(1)) SWIG_fail;
23206 {
23207 arg2 = (bool)(SWIG_As_bool(obj1));
23208 if (SWIG_arg_fail(2)) SWIG_fail;
23209 }
23210 {
23211 PyThreadState* __tstate = wxPyBeginAllowThreads();
23212 (arg1)->SetUseBestVisual(arg2);
23213
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 Py_INCREF(Py_None); resultobj = Py_None;
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23225 PyObject *resultobj;
23226 wxPyApp *arg1 = (wxPyApp *) 0 ;
23227 bool result;
23228 PyObject * obj0 = 0 ;
23229 char *kwnames[] = {
23230 (char *) "self", NULL
23231 };
23232
23233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23235 if (SWIG_arg_fail(1)) SWIG_fail;
23236 {
23237 PyThreadState* __tstate = wxPyBeginAllowThreads();
23238 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23239
23240 wxPyEndAllowThreads(__tstate);
23241 if (PyErr_Occurred()) SWIG_fail;
23242 }
23243 {
23244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23245 }
23246 return resultobj;
23247 fail:
23248 return NULL;
23249 }
23250
23251
23252 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23253 PyObject *resultobj;
23254 wxPyApp *arg1 = (wxPyApp *) 0 ;
23255 int arg2 ;
23256 PyObject * obj0 = 0 ;
23257 PyObject * obj1 = 0 ;
23258 char *kwnames[] = {
23259 (char *) "self",(char *) "mode", NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(1)) SWIG_fail;
23265 {
23266 arg2 = (int)(SWIG_As_int(obj1));
23267 if (SWIG_arg_fail(2)) SWIG_fail;
23268 }
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 (arg1)->SetPrintMode(arg2);
23272
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 Py_INCREF(Py_None); resultobj = Py_None;
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj;
23285 wxPyApp *arg1 = (wxPyApp *) 0 ;
23286 int result;
23287 PyObject * obj0 = 0 ;
23288 char *kwnames[] = {
23289 (char *) "self", NULL
23290 };
23291
23292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23294 if (SWIG_arg_fail(1)) SWIG_fail;
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23298
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 {
23303 resultobj = SWIG_From_int((int)(result));
23304 }
23305 return resultobj;
23306 fail:
23307 return NULL;
23308 }
23309
23310
23311 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23312 PyObject *resultobj;
23313 wxPyApp *arg1 = (wxPyApp *) 0 ;
23314 int arg2 ;
23315 PyObject * obj0 = 0 ;
23316 PyObject * obj1 = 0 ;
23317 char *kwnames[] = {
23318 (char *) "self",(char *) "mode", NULL
23319 };
23320
23321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23323 if (SWIG_arg_fail(1)) SWIG_fail;
23324 {
23325 arg2 = (int)(SWIG_As_int(obj1));
23326 if (SWIG_arg_fail(2)) SWIG_fail;
23327 }
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 (arg1)->SetAssertMode(arg2);
23331
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 Py_INCREF(Py_None); resultobj = Py_None;
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23343 PyObject *resultobj;
23344 wxPyApp *arg1 = (wxPyApp *) 0 ;
23345 int result;
23346 PyObject * obj0 = 0 ;
23347 char *kwnames[] = {
23348 (char *) "self", NULL
23349 };
23350
23351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23353 if (SWIG_arg_fail(1)) SWIG_fail;
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 result = (int)(arg1)->GetAssertMode();
23357
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 {
23362 resultobj = SWIG_From_int((int)(result));
23363 }
23364 return resultobj;
23365 fail:
23366 return NULL;
23367 }
23368
23369
23370 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj;
23372 bool result;
23373 char *kwnames[] = {
23374 NULL
23375 };
23376
23377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23378 {
23379 PyThreadState* __tstate = wxPyBeginAllowThreads();
23380 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23381
23382 wxPyEndAllowThreads(__tstate);
23383 if (PyErr_Occurred()) SWIG_fail;
23384 }
23385 {
23386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23387 }
23388 return resultobj;
23389 fail:
23390 return NULL;
23391 }
23392
23393
23394 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23395 PyObject *resultobj;
23396 long result;
23397 char *kwnames[] = {
23398 NULL
23399 };
23400
23401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23402 {
23403 PyThreadState* __tstate = wxPyBeginAllowThreads();
23404 result = (long)wxPyApp::GetMacAboutMenuItemId();
23405
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 {
23410 resultobj = SWIG_From_long((long)(result));
23411 }
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23419 PyObject *resultobj;
23420 long result;
23421 char *kwnames[] = {
23422 NULL
23423 };
23424
23425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23429
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 {
23434 resultobj = SWIG_From_long((long)(result));
23435 }
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj;
23444 long result;
23445 char *kwnames[] = {
23446 NULL
23447 };
23448
23449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23450 {
23451 PyThreadState* __tstate = wxPyBeginAllowThreads();
23452 result = (long)wxPyApp::GetMacExitMenuItemId();
23453
23454 wxPyEndAllowThreads(__tstate);
23455 if (PyErr_Occurred()) SWIG_fail;
23456 }
23457 {
23458 resultobj = SWIG_From_long((long)(result));
23459 }
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23467 PyObject *resultobj;
23468 wxString result;
23469 char *kwnames[] = {
23470 NULL
23471 };
23472
23473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23474 {
23475 PyThreadState* __tstate = wxPyBeginAllowThreads();
23476 result = wxPyApp::GetMacHelpMenuTitleName();
23477
23478 wxPyEndAllowThreads(__tstate);
23479 if (PyErr_Occurred()) SWIG_fail;
23480 }
23481 {
23482 #if wxUSE_UNICODE
23483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23484 #else
23485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23486 #endif
23487 }
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23495 PyObject *resultobj;
23496 bool arg1 ;
23497 PyObject * obj0 = 0 ;
23498 char *kwnames[] = {
23499 (char *) "val", NULL
23500 };
23501
23502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23503 {
23504 arg1 = (bool)(SWIG_As_bool(obj0));
23505 if (SWIG_arg_fail(1)) SWIG_fail;
23506 }
23507 {
23508 PyThreadState* __tstate = wxPyBeginAllowThreads();
23509 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23510
23511 wxPyEndAllowThreads(__tstate);
23512 if (PyErr_Occurred()) SWIG_fail;
23513 }
23514 Py_INCREF(Py_None); resultobj = Py_None;
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23522 PyObject *resultobj;
23523 long arg1 ;
23524 PyObject * obj0 = 0 ;
23525 char *kwnames[] = {
23526 (char *) "val", NULL
23527 };
23528
23529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23530 {
23531 arg1 = (long)(SWIG_As_long(obj0));
23532 if (SWIG_arg_fail(1)) SWIG_fail;
23533 }
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 wxPyApp::SetMacAboutMenuItemId(arg1);
23537
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 Py_INCREF(Py_None); resultobj = Py_None;
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj;
23550 long arg1 ;
23551 PyObject * obj0 = 0 ;
23552 char *kwnames[] = {
23553 (char *) "val", NULL
23554 };
23555
23556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23557 {
23558 arg1 = (long)(SWIG_As_long(obj0));
23559 if (SWIG_arg_fail(1)) SWIG_fail;
23560 }
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23564
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 Py_INCREF(Py_None); resultobj = Py_None;
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj;
23577 long arg1 ;
23578 PyObject * obj0 = 0 ;
23579 char *kwnames[] = {
23580 (char *) "val", NULL
23581 };
23582
23583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23584 {
23585 arg1 = (long)(SWIG_As_long(obj0));
23586 if (SWIG_arg_fail(1)) SWIG_fail;
23587 }
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 wxPyApp::SetMacExitMenuItemId(arg1);
23591
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 Py_INCREF(Py_None); resultobj = Py_None;
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj;
23604 wxString *arg1 = 0 ;
23605 bool temp1 = false ;
23606 PyObject * obj0 = 0 ;
23607 char *kwnames[] = {
23608 (char *) "val", NULL
23609 };
23610
23611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23612 {
23613 arg1 = wxString_in_helper(obj0);
23614 if (arg1 == NULL) SWIG_fail;
23615 temp1 = true;
23616 }
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23620
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 Py_INCREF(Py_None); resultobj = Py_None;
23625 {
23626 if (temp1)
23627 delete arg1;
23628 }
23629 return resultobj;
23630 fail:
23631 {
23632 if (temp1)
23633 delete arg1;
23634 }
23635 return NULL;
23636 }
23637
23638
23639 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23640 PyObject *resultobj;
23641 wxPyApp *arg1 = (wxPyApp *) 0 ;
23642 PyObject * obj0 = 0 ;
23643 char *kwnames[] = {
23644 (char *) "self", NULL
23645 };
23646
23647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23649 if (SWIG_arg_fail(1)) SWIG_fail;
23650 {
23651 PyThreadState* __tstate = wxPyBeginAllowThreads();
23652 (arg1)->_BootstrapApp();
23653
23654 wxPyEndAllowThreads(__tstate);
23655 if (PyErr_Occurred()) SWIG_fail;
23656 }
23657 Py_INCREF(Py_None); resultobj = Py_None;
23658 return resultobj;
23659 fail:
23660 return NULL;
23661 }
23662
23663
23664 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23665 PyObject *resultobj;
23666 int result;
23667 char *kwnames[] = {
23668 NULL
23669 };
23670
23671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 result = (int)wxPyApp::GetComCtl32Version();
23675
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 {
23680 resultobj = SWIG_From_int((int)(result));
23681 }
23682 return resultobj;
23683 fail:
23684 return NULL;
23685 }
23686
23687
23688 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23689 PyObject *obj;
23690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23691 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23692 Py_INCREF(obj);
23693 return Py_BuildValue((char *)"");
23694 }
23695 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj;
23697 char *kwnames[] = {
23698 NULL
23699 };
23700
23701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23702 {
23703 PyThreadState* __tstate = wxPyBeginAllowThreads();
23704 wxExit();
23705
23706 wxPyEndAllowThreads(__tstate);
23707 if (PyErr_Occurred()) SWIG_fail;
23708 }
23709 Py_INCREF(Py_None); resultobj = Py_None;
23710 return resultobj;
23711 fail:
23712 return NULL;
23713 }
23714
23715
23716 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23717 PyObject *resultobj;
23718 bool result;
23719 char *kwnames[] = {
23720 NULL
23721 };
23722
23723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23724 {
23725 PyThreadState* __tstate = wxPyBeginAllowThreads();
23726 result = (bool)wxYield();
23727
23728 wxPyEndAllowThreads(__tstate);
23729 if (PyErr_Occurred()) SWIG_fail;
23730 }
23731 {
23732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23733 }
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj;
23742 bool result;
23743 char *kwnames[] = {
23744 NULL
23745 };
23746
23747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 result = (bool)wxYieldIfNeeded();
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 {
23756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23757 }
23758 return resultobj;
23759 fail:
23760 return NULL;
23761 }
23762
23763
23764 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23765 PyObject *resultobj;
23766 wxWindow *arg1 = (wxWindow *) NULL ;
23767 bool arg2 = (bool) false ;
23768 bool result;
23769 PyObject * obj0 = 0 ;
23770 PyObject * obj1 = 0 ;
23771 char *kwnames[] = {
23772 (char *) "win",(char *) "onlyIfNeeded", NULL
23773 };
23774
23775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23776 if (obj0) {
23777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23778 if (SWIG_arg_fail(1)) SWIG_fail;
23779 }
23780 if (obj1) {
23781 {
23782 arg2 = (bool)(SWIG_As_bool(obj1));
23783 if (SWIG_arg_fail(2)) SWIG_fail;
23784 }
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = (bool)wxSafeYield(arg1,arg2);
23789
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 {
23794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23795 }
23796 return resultobj;
23797 fail:
23798 return NULL;
23799 }
23800
23801
23802 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23803 PyObject *resultobj;
23804 char *kwnames[] = {
23805 NULL
23806 };
23807
23808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 wxWakeUpIdle();
23812
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 Py_INCREF(Py_None); resultobj = Py_None;
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj;
23825 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23826 wxEvent *arg2 = 0 ;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829 char *kwnames[] = {
23830 (char *) "dest",(char *) "event", NULL
23831 };
23832
23833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23835 if (SWIG_arg_fail(1)) SWIG_fail;
23836 {
23837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23838 if (SWIG_arg_fail(2)) SWIG_fail;
23839 if (arg2 == NULL) {
23840 SWIG_null_ref("wxEvent");
23841 }
23842 if (SWIG_arg_fail(2)) SWIG_fail;
23843 }
23844 {
23845 PyThreadState* __tstate = wxPyBeginAllowThreads();
23846 wxPostEvent(arg1,*arg2);
23847
23848 wxPyEndAllowThreads(__tstate);
23849 if (PyErr_Occurred()) SWIG_fail;
23850 }
23851 Py_INCREF(Py_None); resultobj = Py_None;
23852 return resultobj;
23853 fail:
23854 return NULL;
23855 }
23856
23857
23858 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23859 PyObject *resultobj;
23860 char *kwnames[] = {
23861 NULL
23862 };
23863
23864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 wxApp_CleanUp();
23868
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 Py_INCREF(Py_None); resultobj = Py_None;
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj;
23881 wxPyApp *result;
23882 char *kwnames[] = {
23883 NULL
23884 };
23885
23886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 result = (wxPyApp *)wxPyGetApp();
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 {
23895 resultobj = wxPyMake_wxObject(result, 0);
23896 }
23897 return resultobj;
23898 fail:
23899 return NULL;
23900 }
23901
23902
23903 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23904 PyObject *resultobj;
23905 char *arg1 = (char *) 0 ;
23906 PyObject * obj0 = 0 ;
23907 char *kwnames[] = {
23908 (char *) "encoding", NULL
23909 };
23910
23911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23912 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23913 SWIG_arg_fail(1);SWIG_fail;
23914 }
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 wxSetDefaultPyEncoding((char const *)arg1);
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 Py_INCREF(Py_None); resultobj = Py_None;
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 char *result;
23932 char *kwnames[] = {
23933 NULL
23934 };
23935
23936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = (char *)wxGetDefaultPyEncoding();
23940
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_FromCharPtr(result);
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj;
23953 wxEventLoop *result;
23954 char *kwnames[] = {
23955 NULL
23956 };
23957
23958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (wxEventLoop *)new wxEventLoop();
23962
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23974 PyObject *resultobj;
23975 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23976 PyObject * obj0 = 0 ;
23977 char *kwnames[] = {
23978 (char *) "self", NULL
23979 };
23980
23981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23983 if (SWIG_arg_fail(1)) SWIG_fail;
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 delete arg1;
23987
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 Py_INCREF(Py_None); resultobj = Py_None;
23992 return resultobj;
23993 fail:
23994 return NULL;
23995 }
23996
23997
23998 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj;
24000 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24001 int result;
24002 PyObject * obj0 = 0 ;
24003 char *kwnames[] = {
24004 (char *) "self", NULL
24005 };
24006
24007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24009 if (SWIG_arg_fail(1)) SWIG_fail;
24010 {
24011 PyThreadState* __tstate = wxPyBeginAllowThreads();
24012 result = (int)(arg1)->Run();
24013
24014 wxPyEndAllowThreads(__tstate);
24015 if (PyErr_Occurred()) SWIG_fail;
24016 }
24017 {
24018 resultobj = SWIG_From_int((int)(result));
24019 }
24020 return resultobj;
24021 fail:
24022 return NULL;
24023 }
24024
24025
24026 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj;
24028 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24029 int arg2 = (int) 0 ;
24030 PyObject * obj0 = 0 ;
24031 PyObject * obj1 = 0 ;
24032 char *kwnames[] = {
24033 (char *) "self",(char *) "rc", NULL
24034 };
24035
24036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24038 if (SWIG_arg_fail(1)) SWIG_fail;
24039 if (obj1) {
24040 {
24041 arg2 = (int)(SWIG_As_int(obj1));
24042 if (SWIG_arg_fail(2)) SWIG_fail;
24043 }
24044 }
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 (arg1)->Exit(arg2);
24048
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 Py_INCREF(Py_None); resultobj = Py_None;
24053 return resultobj;
24054 fail:
24055 return NULL;
24056 }
24057
24058
24059 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24060 PyObject *resultobj;
24061 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24062 bool result;
24063 PyObject * obj0 = 0 ;
24064 char *kwnames[] = {
24065 (char *) "self", NULL
24066 };
24067
24068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24070 if (SWIG_arg_fail(1)) SWIG_fail;
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 result = (bool)((wxEventLoop const *)arg1)->Pending();
24074
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 {
24079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24080 }
24081 return resultobj;
24082 fail:
24083 return NULL;
24084 }
24085
24086
24087 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24088 PyObject *resultobj;
24089 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24090 bool result;
24091 PyObject * obj0 = 0 ;
24092 char *kwnames[] = {
24093 (char *) "self", NULL
24094 };
24095
24096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24098 if (SWIG_arg_fail(1)) SWIG_fail;
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (bool)(arg1)->Dispatch();
24102
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 {
24107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24108 }
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24116 PyObject *resultobj;
24117 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24118 bool result;
24119 PyObject * obj0 = 0 ;
24120 char *kwnames[] = {
24121 (char *) "self", NULL
24122 };
24123
24124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24126 if (SWIG_arg_fail(1)) SWIG_fail;
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24130
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 {
24135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24144 PyObject *resultobj;
24145 wxEventLoop *result;
24146 char *kwnames[] = {
24147 NULL
24148 };
24149
24150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24151 {
24152 PyThreadState* __tstate = wxPyBeginAllowThreads();
24153 result = (wxEventLoop *)wxEventLoop::GetActive();
24154
24155 wxPyEndAllowThreads(__tstate);
24156 if (PyErr_Occurred()) SWIG_fail;
24157 }
24158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24159 return resultobj;
24160 fail:
24161 return NULL;
24162 }
24163
24164
24165 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24166 PyObject *resultobj;
24167 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24168 PyObject * obj0 = 0 ;
24169 char *kwnames[] = {
24170 (char *) "loop", NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(1)) SWIG_fail;
24176 {
24177 PyThreadState* __tstate = wxPyBeginAllowThreads();
24178 wxEventLoop::SetActive(arg1);
24179
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 Py_INCREF(Py_None); resultobj = Py_None;
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24191 PyObject *obj;
24192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24193 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24194 Py_INCREF(obj);
24195 return Py_BuildValue((char *)"");
24196 }
24197 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj;
24199 int arg1 = (int) 0 ;
24200 int arg2 = (int) 0 ;
24201 int arg3 = (int) 0 ;
24202 wxAcceleratorEntry *result;
24203 PyObject * obj0 = 0 ;
24204 PyObject * obj1 = 0 ;
24205 PyObject * obj2 = 0 ;
24206 char *kwnames[] = {
24207 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24208 };
24209
24210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24211 if (obj0) {
24212 {
24213 arg1 = (int)(SWIG_As_int(obj0));
24214 if (SWIG_arg_fail(1)) SWIG_fail;
24215 }
24216 }
24217 if (obj1) {
24218 {
24219 arg2 = (int)(SWIG_As_int(obj1));
24220 if (SWIG_arg_fail(2)) SWIG_fail;
24221 }
24222 }
24223 if (obj2) {
24224 {
24225 arg3 = (int)(SWIG_As_int(obj2));
24226 if (SWIG_arg_fail(3)) SWIG_fail;
24227 }
24228 }
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24232
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj;
24245 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24246 PyObject * obj0 = 0 ;
24247 char *kwnames[] = {
24248 (char *) "self", NULL
24249 };
24250
24251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24253 if (SWIG_arg_fail(1)) SWIG_fail;
24254 {
24255 PyThreadState* __tstate = wxPyBeginAllowThreads();
24256 delete arg1;
24257
24258 wxPyEndAllowThreads(__tstate);
24259 if (PyErr_Occurred()) SWIG_fail;
24260 }
24261 Py_INCREF(Py_None); resultobj = Py_None;
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24269 PyObject *resultobj;
24270 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24271 int arg2 ;
24272 int arg3 ;
24273 int arg4 ;
24274 PyObject * obj0 = 0 ;
24275 PyObject * obj1 = 0 ;
24276 PyObject * obj2 = 0 ;
24277 PyObject * obj3 = 0 ;
24278 char *kwnames[] = {
24279 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24280 };
24281
24282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24284 if (SWIG_arg_fail(1)) SWIG_fail;
24285 {
24286 arg2 = (int)(SWIG_As_int(obj1));
24287 if (SWIG_arg_fail(2)) SWIG_fail;
24288 }
24289 {
24290 arg3 = (int)(SWIG_As_int(obj2));
24291 if (SWIG_arg_fail(3)) SWIG_fail;
24292 }
24293 {
24294 arg4 = (int)(SWIG_As_int(obj3));
24295 if (SWIG_arg_fail(4)) SWIG_fail;
24296 }
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 (arg1)->Set(arg2,arg3,arg4);
24300
24301 wxPyEndAllowThreads(__tstate);
24302 if (PyErr_Occurred()) SWIG_fail;
24303 }
24304 Py_INCREF(Py_None); resultobj = Py_None;
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj;
24313 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24314 int result;
24315 PyObject * obj0 = 0 ;
24316 char *kwnames[] = {
24317 (char *) "self", NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (int)(arg1)->GetFlags();
24326
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 {
24331 resultobj = SWIG_From_int((int)(result));
24332 }
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24340 PyObject *resultobj;
24341 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24342 int result;
24343 PyObject * obj0 = 0 ;
24344 char *kwnames[] = {
24345 (char *) "self", NULL
24346 };
24347
24348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24350 if (SWIG_arg_fail(1)) SWIG_fail;
24351 {
24352 PyThreadState* __tstate = wxPyBeginAllowThreads();
24353 result = (int)(arg1)->GetKeyCode();
24354
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 {
24359 resultobj = SWIG_From_int((int)(result));
24360 }
24361 return resultobj;
24362 fail:
24363 return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24368 PyObject *resultobj;
24369 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24370 int result;
24371 PyObject * obj0 = 0 ;
24372 char *kwnames[] = {
24373 (char *) "self", NULL
24374 };
24375
24376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24378 if (SWIG_arg_fail(1)) SWIG_fail;
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 result = (int)(arg1)->GetCommand();
24382
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 {
24387 resultobj = SWIG_From_int((int)(result));
24388 }
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24396 PyObject *obj;
24397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24398 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24399 Py_INCREF(obj);
24400 return Py_BuildValue((char *)"");
24401 }
24402 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 int arg1 ;
24405 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24406 wxAcceleratorTable *result;
24407 PyObject * obj0 = 0 ;
24408 char *kwnames[] = {
24409 (char *) "n", NULL
24410 };
24411
24412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24413 {
24414 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24415 if (arg2) arg1 = PyList_Size(obj0);
24416 else arg1 = 0;
24417 }
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24421
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24426 {
24427 delete [] arg2;
24428 }
24429 return resultobj;
24430 fail:
24431 {
24432 delete [] arg2;
24433 }
24434 return NULL;
24435 }
24436
24437
24438 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj;
24440 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24441 PyObject * obj0 = 0 ;
24442 char *kwnames[] = {
24443 (char *) "self", NULL
24444 };
24445
24446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24448 if (SWIG_arg_fail(1)) SWIG_fail;
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 delete arg1;
24452
24453 wxPyEndAllowThreads(__tstate);
24454 if (PyErr_Occurred()) SWIG_fail;
24455 }
24456 Py_INCREF(Py_None); resultobj = Py_None;
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24464 PyObject *resultobj;
24465 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24466 bool result;
24467 PyObject * obj0 = 0 ;
24468 char *kwnames[] = {
24469 (char *) "self", NULL
24470 };
24471
24472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24474 if (SWIG_arg_fail(1)) SWIG_fail;
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24478
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24492 PyObject *obj;
24493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24494 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24495 Py_INCREF(obj);
24496 return Py_BuildValue((char *)"");
24497 }
24498 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24499 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24500 return 1;
24501 }
24502
24503
24504 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24505 PyObject *pyobj;
24506
24507 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24508 return pyobj;
24509 }
24510
24511
24512 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24513 PyObject *resultobj;
24514 wxString *arg1 = 0 ;
24515 wxAcceleratorEntry *result;
24516 bool temp1 = false ;
24517 PyObject * obj0 = 0 ;
24518 char *kwnames[] = {
24519 (char *) "label", NULL
24520 };
24521
24522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24523 {
24524 arg1 = wxString_in_helper(obj0);
24525 if (arg1 == NULL) SWIG_fail;
24526 temp1 = true;
24527 }
24528 {
24529 PyThreadState* __tstate = wxPyBeginAllowThreads();
24530 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24531
24532 wxPyEndAllowThreads(__tstate);
24533 if (PyErr_Occurred()) SWIG_fail;
24534 }
24535 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24536 {
24537 if (temp1)
24538 delete arg1;
24539 }
24540 return resultobj;
24541 fail:
24542 {
24543 if (temp1)
24544 delete arg1;
24545 }
24546 return NULL;
24547 }
24548
24549
24550 static int _wrap_PanelNameStr_set(PyObject *) {
24551 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24552 return 1;
24553 }
24554
24555
24556 static PyObject *_wrap_PanelNameStr_get(void) {
24557 PyObject *pyobj;
24558
24559 {
24560 #if wxUSE_UNICODE
24561 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24562 #else
24563 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24564 #endif
24565 }
24566 return pyobj;
24567 }
24568
24569
24570 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24571 PyObject *resultobj;
24572 wxVisualAttributes *result;
24573 char *kwnames[] = {
24574 NULL
24575 };
24576
24577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 result = (wxVisualAttributes *)new_wxVisualAttributes();
24581
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24593 PyObject *resultobj;
24594 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24595 PyObject * obj0 = 0 ;
24596 char *kwnames[] = {
24597 (char *) "self", NULL
24598 };
24599
24600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24602 if (SWIG_arg_fail(1)) SWIG_fail;
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 delete_wxVisualAttributes(arg1);
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 Py_INCREF(Py_None); resultobj = Py_None;
24611 return resultobj;
24612 fail:
24613 return NULL;
24614 }
24615
24616
24617 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24618 PyObject *resultobj;
24619 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24620 wxFont *arg2 = (wxFont *) 0 ;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 char *kwnames[] = {
24624 (char *) "self",(char *) "font", NULL
24625 };
24626
24627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24629 if (SWIG_arg_fail(1)) SWIG_fail;
24630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24631 if (SWIG_arg_fail(2)) SWIG_fail;
24632 if (arg1) (arg1)->font = *arg2;
24633
24634 Py_INCREF(Py_None); resultobj = Py_None;
24635 return resultobj;
24636 fail:
24637 return NULL;
24638 }
24639
24640
24641 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj;
24643 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24644 wxFont *result;
24645 PyObject * obj0 = 0 ;
24646 char *kwnames[] = {
24647 (char *) "self", NULL
24648 };
24649
24650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(1)) SWIG_fail;
24653 result = (wxFont *)& ((arg1)->font);
24654
24655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj;
24664 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24665 wxColour *arg2 = (wxColour *) 0 ;
24666 PyObject * obj0 = 0 ;
24667 PyObject * obj1 = 0 ;
24668 char *kwnames[] = {
24669 (char *) "self",(char *) "colFg", NULL
24670 };
24671
24672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24674 if (SWIG_arg_fail(1)) SWIG_fail;
24675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24676 if (SWIG_arg_fail(2)) SWIG_fail;
24677 if (arg1) (arg1)->colFg = *arg2;
24678
24679 Py_INCREF(Py_None); resultobj = Py_None;
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24687 PyObject *resultobj;
24688 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24689 wxColour *result;
24690 PyObject * obj0 = 0 ;
24691 char *kwnames[] = {
24692 (char *) "self", NULL
24693 };
24694
24695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24697 if (SWIG_arg_fail(1)) SWIG_fail;
24698 result = (wxColour *)& ((arg1)->colFg);
24699
24700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24701 return resultobj;
24702 fail:
24703 return NULL;
24704 }
24705
24706
24707 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24708 PyObject *resultobj;
24709 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24710 wxColour *arg2 = (wxColour *) 0 ;
24711 PyObject * obj0 = 0 ;
24712 PyObject * obj1 = 0 ;
24713 char *kwnames[] = {
24714 (char *) "self",(char *) "colBg", NULL
24715 };
24716
24717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24719 if (SWIG_arg_fail(1)) SWIG_fail;
24720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24721 if (SWIG_arg_fail(2)) SWIG_fail;
24722 if (arg1) (arg1)->colBg = *arg2;
24723
24724 Py_INCREF(Py_None); resultobj = Py_None;
24725 return resultobj;
24726 fail:
24727 return NULL;
24728 }
24729
24730
24731 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24732 PyObject *resultobj;
24733 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24734 wxColour *result;
24735 PyObject * obj0 = 0 ;
24736 char *kwnames[] = {
24737 (char *) "self", NULL
24738 };
24739
24740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24742 if (SWIG_arg_fail(1)) SWIG_fail;
24743 result = (wxColour *)& ((arg1)->colBg);
24744
24745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24753 PyObject *obj;
24754 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24755 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24756 Py_INCREF(obj);
24757 return Py_BuildValue((char *)"");
24758 }
24759 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24760 PyObject *resultobj;
24761 wxWindow *arg1 = (wxWindow *) 0 ;
24762 int arg2 = (int) (int)-1 ;
24763 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24764 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24765 wxSize const &arg4_defvalue = wxDefaultSize ;
24766 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24767 long arg5 = (long) 0 ;
24768 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24769 wxString *arg6 = (wxString *) &arg6_defvalue ;
24770 wxWindow *result;
24771 wxPoint temp3 ;
24772 wxSize temp4 ;
24773 bool temp6 = false ;
24774 PyObject * obj0 = 0 ;
24775 PyObject * obj1 = 0 ;
24776 PyObject * obj2 = 0 ;
24777 PyObject * obj3 = 0 ;
24778 PyObject * obj4 = 0 ;
24779 PyObject * obj5 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 if (obj1) {
24788 {
24789 arg2 = (int const)(SWIG_As_int(obj1));
24790 if (SWIG_arg_fail(2)) SWIG_fail;
24791 }
24792 }
24793 if (obj2) {
24794 {
24795 arg3 = &temp3;
24796 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24797 }
24798 }
24799 if (obj3) {
24800 {
24801 arg4 = &temp4;
24802 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24803 }
24804 }
24805 if (obj4) {
24806 {
24807 arg5 = (long)(SWIG_As_long(obj4));
24808 if (SWIG_arg_fail(5)) SWIG_fail;
24809 }
24810 }
24811 if (obj5) {
24812 {
24813 arg6 = wxString_in_helper(obj5);
24814 if (arg6 == NULL) SWIG_fail;
24815 temp6 = true;
24816 }
24817 }
24818 {
24819 if (!wxPyCheckForApp()) SWIG_fail;
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24822
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24827 {
24828 if (temp6)
24829 delete arg6;
24830 }
24831 return resultobj;
24832 fail:
24833 {
24834 if (temp6)
24835 delete arg6;
24836 }
24837 return NULL;
24838 }
24839
24840
24841 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24842 PyObject *resultobj;
24843 wxWindow *result;
24844 char *kwnames[] = {
24845 NULL
24846 };
24847
24848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24849 {
24850 if (!wxPyCheckForApp()) SWIG_fail;
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 result = (wxWindow *)new wxWindow();
24853
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24865 PyObject *resultobj;
24866 wxWindow *arg1 = (wxWindow *) 0 ;
24867 wxWindow *arg2 = (wxWindow *) 0 ;
24868 int arg3 = (int) (int)-1 ;
24869 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24870 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24871 wxSize const &arg5_defvalue = wxDefaultSize ;
24872 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24873 long arg6 = (long) 0 ;
24874 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24875 wxString *arg7 = (wxString *) &arg7_defvalue ;
24876 bool result;
24877 wxPoint temp4 ;
24878 wxSize temp5 ;
24879 bool temp7 = false ;
24880 PyObject * obj0 = 0 ;
24881 PyObject * obj1 = 0 ;
24882 PyObject * obj2 = 0 ;
24883 PyObject * obj3 = 0 ;
24884 PyObject * obj4 = 0 ;
24885 PyObject * obj5 = 0 ;
24886 PyObject * obj6 = 0 ;
24887 char *kwnames[] = {
24888 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24889 };
24890
24891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24893 if (SWIG_arg_fail(1)) SWIG_fail;
24894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24895 if (SWIG_arg_fail(2)) SWIG_fail;
24896 if (obj2) {
24897 {
24898 arg3 = (int const)(SWIG_As_int(obj2));
24899 if (SWIG_arg_fail(3)) SWIG_fail;
24900 }
24901 }
24902 if (obj3) {
24903 {
24904 arg4 = &temp4;
24905 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24906 }
24907 }
24908 if (obj4) {
24909 {
24910 arg5 = &temp5;
24911 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24912 }
24913 }
24914 if (obj5) {
24915 {
24916 arg6 = (long)(SWIG_As_long(obj5));
24917 if (SWIG_arg_fail(6)) SWIG_fail;
24918 }
24919 }
24920 if (obj6) {
24921 {
24922 arg7 = wxString_in_helper(obj6);
24923 if (arg7 == NULL) SWIG_fail;
24924 temp7 = true;
24925 }
24926 }
24927 {
24928 PyThreadState* __tstate = wxPyBeginAllowThreads();
24929 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24930
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 {
24935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24936 }
24937 {
24938 if (temp7)
24939 delete arg7;
24940 }
24941 return resultobj;
24942 fail:
24943 {
24944 if (temp7)
24945 delete arg7;
24946 }
24947 return NULL;
24948 }
24949
24950
24951 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj;
24953 wxWindow *arg1 = (wxWindow *) 0 ;
24954 bool arg2 = (bool) false ;
24955 bool result;
24956 PyObject * obj0 = 0 ;
24957 PyObject * obj1 = 0 ;
24958 char *kwnames[] = {
24959 (char *) "self",(char *) "force", NULL
24960 };
24961
24962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24964 if (SWIG_arg_fail(1)) SWIG_fail;
24965 if (obj1) {
24966 {
24967 arg2 = (bool)(SWIG_As_bool(obj1));
24968 if (SWIG_arg_fail(2)) SWIG_fail;
24969 }
24970 }
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 result = (bool)(arg1)->Close(arg2);
24974
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24980 }
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24988 PyObject *resultobj;
24989 wxWindow *arg1 = (wxWindow *) 0 ;
24990 bool result;
24991 PyObject * obj0 = 0 ;
24992 char *kwnames[] = {
24993 (char *) "self", NULL
24994 };
24995
24996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24998 if (SWIG_arg_fail(1)) SWIG_fail;
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (bool)(arg1)->Destroy();
25002
25003 wxPyEndAllowThreads(__tstate);
25004 if (PyErr_Occurred()) SWIG_fail;
25005 }
25006 {
25007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25008 }
25009 return resultobj;
25010 fail:
25011 return NULL;
25012 }
25013
25014
25015 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25016 PyObject *resultobj;
25017 wxWindow *arg1 = (wxWindow *) 0 ;
25018 bool result;
25019 PyObject * obj0 = 0 ;
25020 char *kwnames[] = {
25021 (char *) "self", NULL
25022 };
25023
25024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25026 if (SWIG_arg_fail(1)) SWIG_fail;
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (bool)(arg1)->DestroyChildren();
25030
25031 wxPyEndAllowThreads(__tstate);
25032 if (PyErr_Occurred()) SWIG_fail;
25033 }
25034 {
25035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25036 }
25037 return resultobj;
25038 fail:
25039 return NULL;
25040 }
25041
25042
25043 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25044 PyObject *resultobj;
25045 wxWindow *arg1 = (wxWindow *) 0 ;
25046 bool result;
25047 PyObject * obj0 = 0 ;
25048 char *kwnames[] = {
25049 (char *) "self", NULL
25050 };
25051
25052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25054 if (SWIG_arg_fail(1)) SWIG_fail;
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25058
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 {
25063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25064 }
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj;
25073 wxWindow *arg1 = (wxWindow *) 0 ;
25074 wxString *arg2 = 0 ;
25075 bool temp2 = false ;
25076 PyObject * obj0 = 0 ;
25077 PyObject * obj1 = 0 ;
25078 char *kwnames[] = {
25079 (char *) "self",(char *) "title", NULL
25080 };
25081
25082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25084 if (SWIG_arg_fail(1)) SWIG_fail;
25085 {
25086 arg2 = wxString_in_helper(obj1);
25087 if (arg2 == NULL) SWIG_fail;
25088 temp2 = true;
25089 }
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 (arg1)->SetTitle((wxString const &)*arg2);
25093
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 Py_INCREF(Py_None); resultobj = Py_None;
25098 {
25099 if (temp2)
25100 delete arg2;
25101 }
25102 return resultobj;
25103 fail:
25104 {
25105 if (temp2)
25106 delete arg2;
25107 }
25108 return NULL;
25109 }
25110
25111
25112 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj;
25114 wxWindow *arg1 = (wxWindow *) 0 ;
25115 wxString result;
25116 PyObject * obj0 = 0 ;
25117 char *kwnames[] = {
25118 (char *) "self", NULL
25119 };
25120
25121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25123 if (SWIG_arg_fail(1)) SWIG_fail;
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = ((wxWindow const *)arg1)->GetTitle();
25127
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 {
25132 #if wxUSE_UNICODE
25133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25134 #else
25135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25136 #endif
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj;
25146 wxWindow *arg1 = (wxWindow *) 0 ;
25147 wxString *arg2 = 0 ;
25148 bool temp2 = false ;
25149 PyObject * obj0 = 0 ;
25150 PyObject * obj1 = 0 ;
25151 char *kwnames[] = {
25152 (char *) "self",(char *) "label", NULL
25153 };
25154
25155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25157 if (SWIG_arg_fail(1)) SWIG_fail;
25158 {
25159 arg2 = wxString_in_helper(obj1);
25160 if (arg2 == NULL) SWIG_fail;
25161 temp2 = true;
25162 }
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 (arg1)->SetLabel((wxString const &)*arg2);
25166
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 Py_INCREF(Py_None); resultobj = Py_None;
25171 {
25172 if (temp2)
25173 delete arg2;
25174 }
25175 return resultobj;
25176 fail:
25177 {
25178 if (temp2)
25179 delete arg2;
25180 }
25181 return NULL;
25182 }
25183
25184
25185 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj;
25187 wxWindow *arg1 = (wxWindow *) 0 ;
25188 wxString result;
25189 PyObject * obj0 = 0 ;
25190 char *kwnames[] = {
25191 (char *) "self", NULL
25192 };
25193
25194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25196 if (SWIG_arg_fail(1)) SWIG_fail;
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = ((wxWindow const *)arg1)->GetLabel();
25200
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 {
25205 #if wxUSE_UNICODE
25206 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25207 #else
25208 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25209 #endif
25210 }
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj;
25219 wxWindow *arg1 = (wxWindow *) 0 ;
25220 wxString *arg2 = 0 ;
25221 bool temp2 = false ;
25222 PyObject * obj0 = 0 ;
25223 PyObject * obj1 = 0 ;
25224 char *kwnames[] = {
25225 (char *) "self",(char *) "name", NULL
25226 };
25227
25228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25230 if (SWIG_arg_fail(1)) SWIG_fail;
25231 {
25232 arg2 = wxString_in_helper(obj1);
25233 if (arg2 == NULL) SWIG_fail;
25234 temp2 = true;
25235 }
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 (arg1)->SetName((wxString const &)*arg2);
25239
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 Py_INCREF(Py_None); resultobj = Py_None;
25244 {
25245 if (temp2)
25246 delete arg2;
25247 }
25248 return resultobj;
25249 fail:
25250 {
25251 if (temp2)
25252 delete arg2;
25253 }
25254 return NULL;
25255 }
25256
25257
25258 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25259 PyObject *resultobj;
25260 wxWindow *arg1 = (wxWindow *) 0 ;
25261 wxString result;
25262 PyObject * obj0 = 0 ;
25263 char *kwnames[] = {
25264 (char *) "self", NULL
25265 };
25266
25267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25269 if (SWIG_arg_fail(1)) SWIG_fail;
25270 {
25271 PyThreadState* __tstate = wxPyBeginAllowThreads();
25272 result = ((wxWindow const *)arg1)->GetName();
25273
25274 wxPyEndAllowThreads(__tstate);
25275 if (PyErr_Occurred()) SWIG_fail;
25276 }
25277 {
25278 #if wxUSE_UNICODE
25279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25280 #else
25281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25282 #endif
25283 }
25284 return resultobj;
25285 fail:
25286 return NULL;
25287 }
25288
25289
25290 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25291 PyObject *resultobj;
25292 wxWindow *arg1 = (wxWindow *) 0 ;
25293 wxWindowVariant arg2 ;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 char *kwnames[] = {
25297 (char *) "self",(char *) "variant", NULL
25298 };
25299
25300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25302 if (SWIG_arg_fail(1)) SWIG_fail;
25303 {
25304 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25305 if (SWIG_arg_fail(2)) SWIG_fail;
25306 }
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25310
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 Py_INCREF(Py_None); resultobj = Py_None;
25315 return resultobj;
25316 fail:
25317 return NULL;
25318 }
25319
25320
25321 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25322 PyObject *resultobj;
25323 wxWindow *arg1 = (wxWindow *) 0 ;
25324 wxWindowVariant result;
25325 PyObject * obj0 = 0 ;
25326 char *kwnames[] = {
25327 (char *) "self", NULL
25328 };
25329
25330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25332 if (SWIG_arg_fail(1)) SWIG_fail;
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25336
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 resultobj = SWIG_From_int((result));
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25348 PyObject *resultobj;
25349 wxWindow *arg1 = (wxWindow *) 0 ;
25350 int arg2 ;
25351 PyObject * obj0 = 0 ;
25352 PyObject * obj1 = 0 ;
25353 char *kwnames[] = {
25354 (char *) "self",(char *) "winid", NULL
25355 };
25356
25357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25359 if (SWIG_arg_fail(1)) SWIG_fail;
25360 {
25361 arg2 = (int)(SWIG_As_int(obj1));
25362 if (SWIG_arg_fail(2)) SWIG_fail;
25363 }
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 (arg1)->SetId(arg2);
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 Py_INCREF(Py_None); resultobj = Py_None;
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj;
25380 wxWindow *arg1 = (wxWindow *) 0 ;
25381 int result;
25382 PyObject * obj0 = 0 ;
25383 char *kwnames[] = {
25384 (char *) "self", NULL
25385 };
25386
25387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25389 if (SWIG_arg_fail(1)) SWIG_fail;
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 result = (int)((wxWindow const *)arg1)->GetId();
25393
25394 wxPyEndAllowThreads(__tstate);
25395 if (PyErr_Occurred()) SWIG_fail;
25396 }
25397 {
25398 resultobj = SWIG_From_int((int)(result));
25399 }
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25407 PyObject *resultobj;
25408 int result;
25409 char *kwnames[] = {
25410 NULL
25411 };
25412
25413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25414 {
25415 PyThreadState* __tstate = wxPyBeginAllowThreads();
25416 result = (int)wxWindow::NewControlId();
25417
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 {
25422 resultobj = SWIG_From_int((int)(result));
25423 }
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj;
25432 int arg1 ;
25433 int result;
25434 PyObject * obj0 = 0 ;
25435 char *kwnames[] = {
25436 (char *) "winid", NULL
25437 };
25438
25439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25440 {
25441 arg1 = (int)(SWIG_As_int(obj0));
25442 if (SWIG_arg_fail(1)) SWIG_fail;
25443 }
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 result = (int)wxWindow::NextControlId(arg1);
25447
25448 wxPyEndAllowThreads(__tstate);
25449 if (PyErr_Occurred()) SWIG_fail;
25450 }
25451 {
25452 resultobj = SWIG_From_int((int)(result));
25453 }
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj;
25462 int arg1 ;
25463 int result;
25464 PyObject * obj0 = 0 ;
25465 char *kwnames[] = {
25466 (char *) "winid", NULL
25467 };
25468
25469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25470 {
25471 arg1 = (int)(SWIG_As_int(obj0));
25472 if (SWIG_arg_fail(1)) SWIG_fail;
25473 }
25474 {
25475 PyThreadState* __tstate = wxPyBeginAllowThreads();
25476 result = (int)wxWindow::PrevControlId(arg1);
25477
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 {
25482 resultobj = SWIG_From_int((int)(result));
25483 }
25484 return resultobj;
25485 fail:
25486 return NULL;
25487 }
25488
25489
25490 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25491 PyObject *resultobj;
25492 wxWindow *arg1 = (wxWindow *) 0 ;
25493 wxSize *arg2 = 0 ;
25494 wxSize temp2 ;
25495 PyObject * obj0 = 0 ;
25496 PyObject * obj1 = 0 ;
25497 char *kwnames[] = {
25498 (char *) "self",(char *) "size", NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25503 if (SWIG_arg_fail(1)) SWIG_fail;
25504 {
25505 arg2 = &temp2;
25506 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25507 }
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 (arg1)->SetSize((wxSize const &)*arg2);
25511
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 Py_INCREF(Py_None); resultobj = Py_None;
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj;
25524 wxWindow *arg1 = (wxWindow *) 0 ;
25525 int arg2 ;
25526 int arg3 ;
25527 int arg4 ;
25528 int arg5 ;
25529 int arg6 = (int) wxSIZE_AUTO ;
25530 PyObject * obj0 = 0 ;
25531 PyObject * obj1 = 0 ;
25532 PyObject * obj2 = 0 ;
25533 PyObject * obj3 = 0 ;
25534 PyObject * obj4 = 0 ;
25535 PyObject * obj5 = 0 ;
25536 char *kwnames[] = {
25537 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25538 };
25539
25540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25542 if (SWIG_arg_fail(1)) SWIG_fail;
25543 {
25544 arg2 = (int)(SWIG_As_int(obj1));
25545 if (SWIG_arg_fail(2)) SWIG_fail;
25546 }
25547 {
25548 arg3 = (int)(SWIG_As_int(obj2));
25549 if (SWIG_arg_fail(3)) SWIG_fail;
25550 }
25551 {
25552 arg4 = (int)(SWIG_As_int(obj3));
25553 if (SWIG_arg_fail(4)) SWIG_fail;
25554 }
25555 {
25556 arg5 = (int)(SWIG_As_int(obj4));
25557 if (SWIG_arg_fail(5)) SWIG_fail;
25558 }
25559 if (obj5) {
25560 {
25561 arg6 = (int)(SWIG_As_int(obj5));
25562 if (SWIG_arg_fail(6)) SWIG_fail;
25563 }
25564 }
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25568
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 Py_INCREF(Py_None); resultobj = Py_None;
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25580 PyObject *resultobj;
25581 wxWindow *arg1 = (wxWindow *) 0 ;
25582 wxRect *arg2 = 0 ;
25583 int arg3 = (int) wxSIZE_AUTO ;
25584 wxRect temp2 ;
25585 PyObject * obj0 = 0 ;
25586 PyObject * obj1 = 0 ;
25587 PyObject * obj2 = 0 ;
25588 char *kwnames[] = {
25589 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25590 };
25591
25592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25594 if (SWIG_arg_fail(1)) SWIG_fail;
25595 {
25596 arg2 = &temp2;
25597 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25598 }
25599 if (obj2) {
25600 {
25601 arg3 = (int)(SWIG_As_int(obj2));
25602 if (SWIG_arg_fail(3)) SWIG_fail;
25603 }
25604 }
25605 {
25606 PyThreadState* __tstate = wxPyBeginAllowThreads();
25607 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25608
25609 wxPyEndAllowThreads(__tstate);
25610 if (PyErr_Occurred()) SWIG_fail;
25611 }
25612 Py_INCREF(Py_None); resultobj = Py_None;
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25620 PyObject *resultobj;
25621 wxWindow *arg1 = (wxWindow *) 0 ;
25622 int arg2 ;
25623 int arg3 ;
25624 PyObject * obj0 = 0 ;
25625 PyObject * obj1 = 0 ;
25626 PyObject * obj2 = 0 ;
25627 char *kwnames[] = {
25628 (char *) "self",(char *) "width",(char *) "height", NULL
25629 };
25630
25631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25633 if (SWIG_arg_fail(1)) SWIG_fail;
25634 {
25635 arg2 = (int)(SWIG_As_int(obj1));
25636 if (SWIG_arg_fail(2)) SWIG_fail;
25637 }
25638 {
25639 arg3 = (int)(SWIG_As_int(obj2));
25640 if (SWIG_arg_fail(3)) SWIG_fail;
25641 }
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 (arg1)->SetSize(arg2,arg3);
25645
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 Py_INCREF(Py_None); resultobj = Py_None;
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25657 PyObject *resultobj;
25658 wxWindow *arg1 = (wxWindow *) 0 ;
25659 wxPoint *arg2 = 0 ;
25660 int arg3 = (int) wxSIZE_USE_EXISTING ;
25661 wxPoint temp2 ;
25662 PyObject * obj0 = 0 ;
25663 PyObject * obj1 = 0 ;
25664 PyObject * obj2 = 0 ;
25665 char *kwnames[] = {
25666 (char *) "self",(char *) "pt",(char *) "flags", NULL
25667 };
25668
25669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25671 if (SWIG_arg_fail(1)) SWIG_fail;
25672 {
25673 arg2 = &temp2;
25674 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25675 }
25676 if (obj2) {
25677 {
25678 arg3 = (int)(SWIG_As_int(obj2));
25679 if (SWIG_arg_fail(3)) SWIG_fail;
25680 }
25681 }
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 (arg1)->Move((wxPoint const &)*arg2,arg3);
25685
25686 wxPyEndAllowThreads(__tstate);
25687 if (PyErr_Occurred()) SWIG_fail;
25688 }
25689 Py_INCREF(Py_None); resultobj = Py_None;
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj;
25698 wxWindow *arg1 = (wxWindow *) 0 ;
25699 int arg2 ;
25700 int arg3 ;
25701 int arg4 = (int) wxSIZE_USE_EXISTING ;
25702 PyObject * obj0 = 0 ;
25703 PyObject * obj1 = 0 ;
25704 PyObject * obj2 = 0 ;
25705 PyObject * obj3 = 0 ;
25706 char *kwnames[] = {
25707 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25708 };
25709
25710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25712 if (SWIG_arg_fail(1)) SWIG_fail;
25713 {
25714 arg2 = (int)(SWIG_As_int(obj1));
25715 if (SWIG_arg_fail(2)) SWIG_fail;
25716 }
25717 {
25718 arg3 = (int)(SWIG_As_int(obj2));
25719 if (SWIG_arg_fail(3)) SWIG_fail;
25720 }
25721 if (obj3) {
25722 {
25723 arg4 = (int)(SWIG_As_int(obj3));
25724 if (SWIG_arg_fail(4)) SWIG_fail;
25725 }
25726 }
25727 {
25728 PyThreadState* __tstate = wxPyBeginAllowThreads();
25729 (arg1)->Move(arg2,arg3,arg4);
25730
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 Py_INCREF(Py_None); resultobj = Py_None;
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj;
25743 wxWindow *arg1 = (wxWindow *) 0 ;
25744 wxSize const &arg2_defvalue = wxDefaultSize ;
25745 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25746 wxSize temp2 ;
25747 PyObject * obj0 = 0 ;
25748 PyObject * obj1 = 0 ;
25749 char *kwnames[] = {
25750 (char *) "self",(char *) "size", NULL
25751 };
25752
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 if (obj1) {
25757 {
25758 arg2 = &temp2;
25759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25760 }
25761 }
25762 {
25763 PyThreadState* __tstate = wxPyBeginAllowThreads();
25764 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25765
25766 wxPyEndAllowThreads(__tstate);
25767 if (PyErr_Occurred()) SWIG_fail;
25768 }
25769 Py_INCREF(Py_None); resultobj = Py_None;
25770 return resultobj;
25771 fail:
25772 return NULL;
25773 }
25774
25775
25776 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj;
25778 wxWindow *arg1 = (wxWindow *) 0 ;
25779 PyObject * obj0 = 0 ;
25780 char *kwnames[] = {
25781 (char *) "self", NULL
25782 };
25783
25784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25786 if (SWIG_arg_fail(1)) SWIG_fail;
25787 {
25788 PyThreadState* __tstate = wxPyBeginAllowThreads();
25789 (arg1)->Raise();
25790
25791 wxPyEndAllowThreads(__tstate);
25792 if (PyErr_Occurred()) SWIG_fail;
25793 }
25794 Py_INCREF(Py_None); resultobj = Py_None;
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj;
25803 wxWindow *arg1 = (wxWindow *) 0 ;
25804 PyObject * obj0 = 0 ;
25805 char *kwnames[] = {
25806 (char *) "self", NULL
25807 };
25808
25809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25811 if (SWIG_arg_fail(1)) SWIG_fail;
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 (arg1)->Lower();
25815
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 Py_INCREF(Py_None); resultobj = Py_None;
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25827 PyObject *resultobj;
25828 wxWindow *arg1 = (wxWindow *) 0 ;
25829 wxSize *arg2 = 0 ;
25830 wxSize temp2 ;
25831 PyObject * obj0 = 0 ;
25832 PyObject * obj1 = 0 ;
25833 char *kwnames[] = {
25834 (char *) "self",(char *) "size", NULL
25835 };
25836
25837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25839 if (SWIG_arg_fail(1)) SWIG_fail;
25840 {
25841 arg2 = &temp2;
25842 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25843 }
25844 {
25845 PyThreadState* __tstate = wxPyBeginAllowThreads();
25846 (arg1)->SetClientSize((wxSize const &)*arg2);
25847
25848 wxPyEndAllowThreads(__tstate);
25849 if (PyErr_Occurred()) SWIG_fail;
25850 }
25851 Py_INCREF(Py_None); resultobj = Py_None;
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj;
25860 wxWindow *arg1 = (wxWindow *) 0 ;
25861 int arg2 ;
25862 int arg3 ;
25863 PyObject * obj0 = 0 ;
25864 PyObject * obj1 = 0 ;
25865 PyObject * obj2 = 0 ;
25866 char *kwnames[] = {
25867 (char *) "self",(char *) "width",(char *) "height", NULL
25868 };
25869
25870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25872 if (SWIG_arg_fail(1)) SWIG_fail;
25873 {
25874 arg2 = (int)(SWIG_As_int(obj1));
25875 if (SWIG_arg_fail(2)) SWIG_fail;
25876 }
25877 {
25878 arg3 = (int)(SWIG_As_int(obj2));
25879 if (SWIG_arg_fail(3)) SWIG_fail;
25880 }
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 (arg1)->SetClientSize(arg2,arg3);
25884
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 Py_INCREF(Py_None); resultobj = Py_None;
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj;
25897 wxWindow *arg1 = (wxWindow *) 0 ;
25898 wxRect *arg2 = 0 ;
25899 wxRect temp2 ;
25900 PyObject * obj0 = 0 ;
25901 PyObject * obj1 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self",(char *) "rect", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 {
25910 arg2 = &temp2;
25911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25912 }
25913 {
25914 PyThreadState* __tstate = wxPyBeginAllowThreads();
25915 (arg1)->SetClientSize((wxRect const &)*arg2);
25916
25917 wxPyEndAllowThreads(__tstate);
25918 if (PyErr_Occurred()) SWIG_fail;
25919 }
25920 Py_INCREF(Py_None); resultobj = Py_None;
25921 return resultobj;
25922 fail:
25923 return NULL;
25924 }
25925
25926
25927 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj;
25929 wxWindow *arg1 = (wxWindow *) 0 ;
25930 wxPoint result;
25931 PyObject * obj0 = 0 ;
25932 char *kwnames[] = {
25933 (char *) "self", NULL
25934 };
25935
25936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25938 if (SWIG_arg_fail(1)) SWIG_fail;
25939 {
25940 PyThreadState* __tstate = wxPyBeginAllowThreads();
25941 result = (arg1)->GetPosition();
25942
25943 wxPyEndAllowThreads(__tstate);
25944 if (PyErr_Occurred()) SWIG_fail;
25945 }
25946 {
25947 wxPoint * resultptr;
25948 resultptr = new wxPoint((wxPoint &)(result));
25949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25950 }
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj;
25959 wxWindow *arg1 = (wxWindow *) 0 ;
25960 int *arg2 = (int *) 0 ;
25961 int *arg3 = (int *) 0 ;
25962 int temp2 ;
25963 int res2 = 0 ;
25964 int temp3 ;
25965 int res3 = 0 ;
25966 PyObject * obj0 = 0 ;
25967 char *kwnames[] = {
25968 (char *) "self", NULL
25969 };
25970
25971 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25972 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25975 if (SWIG_arg_fail(1)) SWIG_fail;
25976 {
25977 PyThreadState* __tstate = wxPyBeginAllowThreads();
25978 (arg1)->GetPosition(arg2,arg3);
25979
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 Py_INCREF(Py_None); resultobj = Py_None;
25984 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25985 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25986 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25987 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25995 PyObject *resultobj;
25996 wxWindow *arg1 = (wxWindow *) 0 ;
25997 wxSize result;
25998 PyObject * obj0 = 0 ;
25999 char *kwnames[] = {
26000 (char *) "self", NULL
26001 };
26002
26003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26005 if (SWIG_arg_fail(1)) SWIG_fail;
26006 {
26007 PyThreadState* __tstate = wxPyBeginAllowThreads();
26008 result = ((wxWindow const *)arg1)->GetSize();
26009
26010 wxPyEndAllowThreads(__tstate);
26011 if (PyErr_Occurred()) SWIG_fail;
26012 }
26013 {
26014 wxSize * resultptr;
26015 resultptr = new wxSize((wxSize &)(result));
26016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26017 }
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj;
26026 wxWindow *arg1 = (wxWindow *) 0 ;
26027 int *arg2 = (int *) 0 ;
26028 int *arg3 = (int *) 0 ;
26029 int temp2 ;
26030 int res2 = 0 ;
26031 int temp3 ;
26032 int res3 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 char *kwnames[] = {
26035 (char *) "self", NULL
26036 };
26037
26038 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26039 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26042 if (SWIG_arg_fail(1)) SWIG_fail;
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26046
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 Py_INCREF(Py_None); resultobj = Py_None;
26051 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26052 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26053 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26054 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26062 PyObject *resultobj;
26063 wxWindow *arg1 = (wxWindow *) 0 ;
26064 wxRect result;
26065 PyObject * obj0 = 0 ;
26066 char *kwnames[] = {
26067 (char *) "self", NULL
26068 };
26069
26070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26072 if (SWIG_arg_fail(1)) SWIG_fail;
26073 {
26074 PyThreadState* __tstate = wxPyBeginAllowThreads();
26075 result = ((wxWindow const *)arg1)->GetRect();
26076
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 {
26081 wxRect * resultptr;
26082 resultptr = new wxRect((wxRect &)(result));
26083 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26084 }
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj;
26093 wxWindow *arg1 = (wxWindow *) 0 ;
26094 wxSize result;
26095 PyObject * obj0 = 0 ;
26096 char *kwnames[] = {
26097 (char *) "self", NULL
26098 };
26099
26100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26102 if (SWIG_arg_fail(1)) SWIG_fail;
26103 {
26104 PyThreadState* __tstate = wxPyBeginAllowThreads();
26105 result = ((wxWindow const *)arg1)->GetClientSize();
26106
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 {
26111 wxSize * resultptr;
26112 resultptr = new wxSize((wxSize &)(result));
26113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26114 }
26115 return resultobj;
26116 fail:
26117 return NULL;
26118 }
26119
26120
26121 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26122 PyObject *resultobj;
26123 wxWindow *arg1 = (wxWindow *) 0 ;
26124 int *arg2 = (int *) 0 ;
26125 int *arg3 = (int *) 0 ;
26126 int temp2 ;
26127 int res2 = 0 ;
26128 int temp3 ;
26129 int res3 = 0 ;
26130 PyObject * obj0 = 0 ;
26131 char *kwnames[] = {
26132 (char *) "self", NULL
26133 };
26134
26135 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26136 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26139 if (SWIG_arg_fail(1)) SWIG_fail;
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26143
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 Py_INCREF(Py_None); resultobj = Py_None;
26148 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26149 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26150 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26151 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26159 PyObject *resultobj;
26160 wxWindow *arg1 = (wxWindow *) 0 ;
26161 wxPoint result;
26162 PyObject * obj0 = 0 ;
26163 char *kwnames[] = {
26164 (char *) "self", NULL
26165 };
26166
26167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26169 if (SWIG_arg_fail(1)) SWIG_fail;
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26173
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 {
26178 wxPoint * resultptr;
26179 resultptr = new wxPoint((wxPoint &)(result));
26180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26181 }
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26189 PyObject *resultobj;
26190 wxWindow *arg1 = (wxWindow *) 0 ;
26191 wxRect result;
26192 PyObject * obj0 = 0 ;
26193 char *kwnames[] = {
26194 (char *) "self", NULL
26195 };
26196
26197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26199 if (SWIG_arg_fail(1)) SWIG_fail;
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 result = ((wxWindow const *)arg1)->GetClientRect();
26203
26204 wxPyEndAllowThreads(__tstate);
26205 if (PyErr_Occurred()) SWIG_fail;
26206 }
26207 {
26208 wxRect * resultptr;
26209 resultptr = new wxRect((wxRect &)(result));
26210 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26211 }
26212 return resultobj;
26213 fail:
26214 return NULL;
26215 }
26216
26217
26218 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26219 PyObject *resultobj;
26220 wxWindow *arg1 = (wxWindow *) 0 ;
26221 wxSize result;
26222 PyObject * obj0 = 0 ;
26223 char *kwnames[] = {
26224 (char *) "self", NULL
26225 };
26226
26227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26229 if (SWIG_arg_fail(1)) SWIG_fail;
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 result = ((wxWindow const *)arg1)->GetBestSize();
26233
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 {
26238 wxSize * resultptr;
26239 resultptr = new wxSize((wxSize &)(result));
26240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26249 PyObject *resultobj;
26250 wxWindow *arg1 = (wxWindow *) 0 ;
26251 int *arg2 = (int *) 0 ;
26252 int *arg3 = (int *) 0 ;
26253 int temp2 ;
26254 int res2 = 0 ;
26255 int temp3 ;
26256 int res3 = 0 ;
26257 PyObject * obj0 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self", NULL
26260 };
26261
26262 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26263 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26266 if (SWIG_arg_fail(1)) SWIG_fail;
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26270
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 Py_INCREF(Py_None); resultobj = Py_None;
26275 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26276 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26277 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26278 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj;
26287 wxWindow *arg1 = (wxWindow *) 0 ;
26288 PyObject * obj0 = 0 ;
26289 char *kwnames[] = {
26290 (char *) "self", NULL
26291 };
26292
26293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26295 if (SWIG_arg_fail(1)) SWIG_fail;
26296 {
26297 PyThreadState* __tstate = wxPyBeginAllowThreads();
26298 (arg1)->InvalidateBestSize();
26299
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 Py_INCREF(Py_None); resultobj = Py_None;
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26311 PyObject *resultobj;
26312 wxWindow *arg1 = (wxWindow *) 0 ;
26313 wxSize result;
26314 PyObject * obj0 = 0 ;
26315 char *kwnames[] = {
26316 (char *) "self", NULL
26317 };
26318
26319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26321 if (SWIG_arg_fail(1)) SWIG_fail;
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26325
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 {
26330 wxSize * resultptr;
26331 resultptr = new wxSize((wxSize &)(result));
26332 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26333 }
26334 return resultobj;
26335 fail:
26336 return NULL;
26337 }
26338
26339
26340 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26341 PyObject *resultobj;
26342 wxWindow *arg1 = (wxWindow *) 0 ;
26343 wxSize result;
26344 PyObject * obj0 = 0 ;
26345 char *kwnames[] = {
26346 (char *) "self", NULL
26347 };
26348
26349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26351 if (SWIG_arg_fail(1)) SWIG_fail;
26352 {
26353 PyThreadState* __tstate = wxPyBeginAllowThreads();
26354 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26355
26356 wxPyEndAllowThreads(__tstate);
26357 if (PyErr_Occurred()) SWIG_fail;
26358 }
26359 {
26360 wxSize * resultptr;
26361 resultptr = new wxSize((wxSize &)(result));
26362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26363 }
26364 return resultobj;
26365 fail:
26366 return NULL;
26367 }
26368
26369
26370 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26371 PyObject *resultobj;
26372 wxWindow *arg1 = (wxWindow *) 0 ;
26373 int arg2 = (int) wxBOTH ;
26374 PyObject * obj0 = 0 ;
26375 PyObject * obj1 = 0 ;
26376 char *kwnames[] = {
26377 (char *) "self",(char *) "direction", NULL
26378 };
26379
26380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26382 if (SWIG_arg_fail(1)) SWIG_fail;
26383 if (obj1) {
26384 {
26385 arg2 = (int)(SWIG_As_int(obj1));
26386 if (SWIG_arg_fail(2)) SWIG_fail;
26387 }
26388 }
26389 {
26390 PyThreadState* __tstate = wxPyBeginAllowThreads();
26391 (arg1)->Center(arg2);
26392
26393 wxPyEndAllowThreads(__tstate);
26394 if (PyErr_Occurred()) SWIG_fail;
26395 }
26396 Py_INCREF(Py_None); resultobj = Py_None;
26397 return resultobj;
26398 fail:
26399 return NULL;
26400 }
26401
26402
26403 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26404 PyObject *resultobj;
26405 wxWindow *arg1 = (wxWindow *) 0 ;
26406 int arg2 = (int) wxBOTH ;
26407 PyObject * obj0 = 0 ;
26408 PyObject * obj1 = 0 ;
26409 char *kwnames[] = {
26410 (char *) "self",(char *) "dir", NULL
26411 };
26412
26413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26415 if (SWIG_arg_fail(1)) SWIG_fail;
26416 if (obj1) {
26417 {
26418 arg2 = (int)(SWIG_As_int(obj1));
26419 if (SWIG_arg_fail(2)) SWIG_fail;
26420 }
26421 }
26422 {
26423 PyThreadState* __tstate = wxPyBeginAllowThreads();
26424 (arg1)->CenterOnScreen(arg2);
26425
26426 wxPyEndAllowThreads(__tstate);
26427 if (PyErr_Occurred()) SWIG_fail;
26428 }
26429 Py_INCREF(Py_None); resultobj = Py_None;
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj;
26438 wxWindow *arg1 = (wxWindow *) 0 ;
26439 int arg2 = (int) wxBOTH ;
26440 PyObject * obj0 = 0 ;
26441 PyObject * obj1 = 0 ;
26442 char *kwnames[] = {
26443 (char *) "self",(char *) "dir", NULL
26444 };
26445
26446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26448 if (SWIG_arg_fail(1)) SWIG_fail;
26449 if (obj1) {
26450 {
26451 arg2 = (int)(SWIG_As_int(obj1));
26452 if (SWIG_arg_fail(2)) SWIG_fail;
26453 }
26454 }
26455 {
26456 PyThreadState* __tstate = wxPyBeginAllowThreads();
26457 (arg1)->CenterOnParent(arg2);
26458
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 Py_INCREF(Py_None); resultobj = Py_None;
26463 return resultobj;
26464 fail:
26465 return NULL;
26466 }
26467
26468
26469 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26470 PyObject *resultobj;
26471 wxWindow *arg1 = (wxWindow *) 0 ;
26472 PyObject * obj0 = 0 ;
26473 char *kwnames[] = {
26474 (char *) "self", NULL
26475 };
26476
26477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26479 if (SWIG_arg_fail(1)) SWIG_fail;
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 (arg1)->Fit();
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_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26495 PyObject *resultobj;
26496 wxWindow *arg1 = (wxWindow *) 0 ;
26497 PyObject * obj0 = 0 ;
26498 char *kwnames[] = {
26499 (char *) "self", NULL
26500 };
26501
26502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26504 if (SWIG_arg_fail(1)) SWIG_fail;
26505 {
26506 PyThreadState* __tstate = wxPyBeginAllowThreads();
26507 (arg1)->FitInside();
26508
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 Py_INCREF(Py_None); resultobj = Py_None;
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26520 PyObject *resultobj;
26521 wxWindow *arg1 = (wxWindow *) 0 ;
26522 int arg2 ;
26523 int arg3 ;
26524 int arg4 = (int) -1 ;
26525 int arg5 = (int) -1 ;
26526 int arg6 = (int) -1 ;
26527 int arg7 = (int) -1 ;
26528 PyObject * obj0 = 0 ;
26529 PyObject * obj1 = 0 ;
26530 PyObject * obj2 = 0 ;
26531 PyObject * obj3 = 0 ;
26532 PyObject * obj4 = 0 ;
26533 PyObject * obj5 = 0 ;
26534 PyObject * obj6 = 0 ;
26535 char *kwnames[] = {
26536 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26537 };
26538
26539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26541 if (SWIG_arg_fail(1)) SWIG_fail;
26542 {
26543 arg2 = (int)(SWIG_As_int(obj1));
26544 if (SWIG_arg_fail(2)) SWIG_fail;
26545 }
26546 {
26547 arg3 = (int)(SWIG_As_int(obj2));
26548 if (SWIG_arg_fail(3)) SWIG_fail;
26549 }
26550 if (obj3) {
26551 {
26552 arg4 = (int)(SWIG_As_int(obj3));
26553 if (SWIG_arg_fail(4)) SWIG_fail;
26554 }
26555 }
26556 if (obj4) {
26557 {
26558 arg5 = (int)(SWIG_As_int(obj4));
26559 if (SWIG_arg_fail(5)) SWIG_fail;
26560 }
26561 }
26562 if (obj5) {
26563 {
26564 arg6 = (int)(SWIG_As_int(obj5));
26565 if (SWIG_arg_fail(6)) SWIG_fail;
26566 }
26567 }
26568 if (obj6) {
26569 {
26570 arg7 = (int)(SWIG_As_int(obj6));
26571 if (SWIG_arg_fail(7)) SWIG_fail;
26572 }
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 Py_INCREF(Py_None); resultobj = Py_None;
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj;
26590 wxWindow *arg1 = (wxWindow *) 0 ;
26591 wxSize *arg2 = 0 ;
26592 wxSize const &arg3_defvalue = wxDefaultSize ;
26593 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26594 wxSize const &arg4_defvalue = wxDefaultSize ;
26595 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26596 wxSize temp2 ;
26597 wxSize temp3 ;
26598 wxSize temp4 ;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601 PyObject * obj2 = 0 ;
26602 PyObject * obj3 = 0 ;
26603 char *kwnames[] = {
26604 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26605 };
26606
26607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26609 if (SWIG_arg_fail(1)) SWIG_fail;
26610 {
26611 arg2 = &temp2;
26612 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26613 }
26614 if (obj2) {
26615 {
26616 arg3 = &temp3;
26617 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26618 }
26619 }
26620 if (obj3) {
26621 {
26622 arg4 = &temp4;
26623 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26624 }
26625 }
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26629
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 Py_INCREF(Py_None); resultobj = Py_None;
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj;
26642 wxWindow *arg1 = (wxWindow *) 0 ;
26643 int arg2 ;
26644 int arg3 ;
26645 int arg4 = (int) -1 ;
26646 int arg5 = (int) -1 ;
26647 PyObject * obj0 = 0 ;
26648 PyObject * obj1 = 0 ;
26649 PyObject * obj2 = 0 ;
26650 PyObject * obj3 = 0 ;
26651 PyObject * obj4 = 0 ;
26652 char *kwnames[] = {
26653 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26654 };
26655
26656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26658 if (SWIG_arg_fail(1)) SWIG_fail;
26659 {
26660 arg2 = (int)(SWIG_As_int(obj1));
26661 if (SWIG_arg_fail(2)) SWIG_fail;
26662 }
26663 {
26664 arg3 = (int)(SWIG_As_int(obj2));
26665 if (SWIG_arg_fail(3)) SWIG_fail;
26666 }
26667 if (obj3) {
26668 {
26669 arg4 = (int)(SWIG_As_int(obj3));
26670 if (SWIG_arg_fail(4)) SWIG_fail;
26671 }
26672 }
26673 if (obj4) {
26674 {
26675 arg5 = (int)(SWIG_As_int(obj4));
26676 if (SWIG_arg_fail(5)) SWIG_fail;
26677 }
26678 }
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 Py_INCREF(Py_None); resultobj = Py_None;
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj;
26695 wxWindow *arg1 = (wxWindow *) 0 ;
26696 wxSize *arg2 = 0 ;
26697 wxSize const &arg3_defvalue = wxDefaultSize ;
26698 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26699 wxSize temp2 ;
26700 wxSize temp3 ;
26701 PyObject * obj0 = 0 ;
26702 PyObject * obj1 = 0 ;
26703 PyObject * obj2 = 0 ;
26704 char *kwnames[] = {
26705 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26706 };
26707
26708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26710 if (SWIG_arg_fail(1)) SWIG_fail;
26711 {
26712 arg2 = &temp2;
26713 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26714 }
26715 if (obj2) {
26716 {
26717 arg3 = &temp3;
26718 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26719 }
26720 }
26721 {
26722 PyThreadState* __tstate = wxPyBeginAllowThreads();
26723 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26724
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 Py_INCREF(Py_None); resultobj = Py_None;
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26736 PyObject *resultobj;
26737 wxWindow *arg1 = (wxWindow *) 0 ;
26738 wxSize result;
26739 PyObject * obj0 = 0 ;
26740 char *kwnames[] = {
26741 (char *) "self", NULL
26742 };
26743
26744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26746 if (SWIG_arg_fail(1)) SWIG_fail;
26747 {
26748 PyThreadState* __tstate = wxPyBeginAllowThreads();
26749 result = ((wxWindow const *)arg1)->GetMaxSize();
26750
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 {
26755 wxSize * resultptr;
26756 resultptr = new wxSize((wxSize &)(result));
26757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26758 }
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj;
26767 wxWindow *arg1 = (wxWindow *) 0 ;
26768 wxSize result;
26769 PyObject * obj0 = 0 ;
26770 char *kwnames[] = {
26771 (char *) "self", NULL
26772 };
26773
26774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26776 if (SWIG_arg_fail(1)) SWIG_fail;
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = ((wxWindow const *)arg1)->GetMinSize();
26780
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 {
26785 wxSize * resultptr;
26786 resultptr = new wxSize((wxSize &)(result));
26787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26788 }
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26796 PyObject *resultobj;
26797 wxWindow *arg1 = (wxWindow *) 0 ;
26798 wxSize *arg2 = 0 ;
26799 wxSize temp2 ;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 char *kwnames[] = {
26803 (char *) "self",(char *) "minSize", NULL
26804 };
26805
26806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26808 if (SWIG_arg_fail(1)) SWIG_fail;
26809 {
26810 arg2 = &temp2;
26811 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26812 }
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 (arg1)->SetMinSize((wxSize const &)*arg2);
26816
26817 wxPyEndAllowThreads(__tstate);
26818 if (PyErr_Occurred()) SWIG_fail;
26819 }
26820 Py_INCREF(Py_None); resultobj = Py_None;
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj;
26829 wxWindow *arg1 = (wxWindow *) 0 ;
26830 wxSize *arg2 = 0 ;
26831 wxSize temp2 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 char *kwnames[] = {
26835 (char *) "self",(char *) "maxSize", NULL
26836 };
26837
26838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26840 if (SWIG_arg_fail(1)) SWIG_fail;
26841 {
26842 arg2 = &temp2;
26843 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26844 }
26845 {
26846 PyThreadState* __tstate = wxPyBeginAllowThreads();
26847 (arg1)->SetMaxSize((wxSize const &)*arg2);
26848
26849 wxPyEndAllowThreads(__tstate);
26850 if (PyErr_Occurred()) SWIG_fail;
26851 }
26852 Py_INCREF(Py_None); resultobj = Py_None;
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj;
26861 wxWindow *arg1 = (wxWindow *) 0 ;
26862 int result;
26863 PyObject * obj0 = 0 ;
26864 char *kwnames[] = {
26865 (char *) "self", NULL
26866 };
26867
26868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26870 if (SWIG_arg_fail(1)) SWIG_fail;
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26874
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 {
26879 resultobj = SWIG_From_int((int)(result));
26880 }
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj;
26889 wxWindow *arg1 = (wxWindow *) 0 ;
26890 int result;
26891 PyObject * obj0 = 0 ;
26892 char *kwnames[] = {
26893 (char *) "self", NULL
26894 };
26895
26896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26898 if (SWIG_arg_fail(1)) SWIG_fail;
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 resultobj = SWIG_From_int((int)(result));
26908 }
26909 return resultobj;
26910 fail:
26911 return NULL;
26912 }
26913
26914
26915 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26916 PyObject *resultobj;
26917 wxWindow *arg1 = (wxWindow *) 0 ;
26918 int result;
26919 PyObject * obj0 = 0 ;
26920 char *kwnames[] = {
26921 (char *) "self", NULL
26922 };
26923
26924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26926 if (SWIG_arg_fail(1)) SWIG_fail;
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26930
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 {
26935 resultobj = SWIG_From_int((int)(result));
26936 }
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26944 PyObject *resultobj;
26945 wxWindow *arg1 = (wxWindow *) 0 ;
26946 int result;
26947 PyObject * obj0 = 0 ;
26948 char *kwnames[] = {
26949 (char *) "self", NULL
26950 };
26951
26952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26954 if (SWIG_arg_fail(1)) SWIG_fail;
26955 {
26956 PyThreadState* __tstate = wxPyBeginAllowThreads();
26957 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26958
26959 wxPyEndAllowThreads(__tstate);
26960 if (PyErr_Occurred()) SWIG_fail;
26961 }
26962 {
26963 resultobj = SWIG_From_int((int)(result));
26964 }
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj;
26973 wxWindow *arg1 = (wxWindow *) 0 ;
26974 wxSize *arg2 = 0 ;
26975 wxSize temp2 ;
26976 PyObject * obj0 = 0 ;
26977 PyObject * obj1 = 0 ;
26978 char *kwnames[] = {
26979 (char *) "self",(char *) "size", NULL
26980 };
26981
26982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26984 if (SWIG_arg_fail(1)) SWIG_fail;
26985 {
26986 arg2 = &temp2;
26987 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26988 }
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26992
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 Py_INCREF(Py_None); resultobj = Py_None;
26997 return resultobj;
26998 fail:
26999 return NULL;
27000 }
27001
27002
27003 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27004 PyObject *resultobj;
27005 wxWindow *arg1 = (wxWindow *) 0 ;
27006 int arg2 ;
27007 int arg3 ;
27008 PyObject * obj0 = 0 ;
27009 PyObject * obj1 = 0 ;
27010 PyObject * obj2 = 0 ;
27011 char *kwnames[] = {
27012 (char *) "self",(char *) "w",(char *) "h", NULL
27013 };
27014
27015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27017 if (SWIG_arg_fail(1)) SWIG_fail;
27018 {
27019 arg2 = (int)(SWIG_As_int(obj1));
27020 if (SWIG_arg_fail(2)) SWIG_fail;
27021 }
27022 {
27023 arg3 = (int)(SWIG_As_int(obj2));
27024 if (SWIG_arg_fail(3)) SWIG_fail;
27025 }
27026 {
27027 PyThreadState* __tstate = wxPyBeginAllowThreads();
27028 (arg1)->SetVirtualSize(arg2,arg3);
27029
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 Py_INCREF(Py_None); resultobj = Py_None;
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj;
27042 wxWindow *arg1 = (wxWindow *) 0 ;
27043 wxSize result;
27044 PyObject * obj0 = 0 ;
27045 char *kwnames[] = {
27046 (char *) "self", NULL
27047 };
27048
27049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27051 if (SWIG_arg_fail(1)) SWIG_fail;
27052 {
27053 PyThreadState* __tstate = wxPyBeginAllowThreads();
27054 result = ((wxWindow const *)arg1)->GetVirtualSize();
27055
27056 wxPyEndAllowThreads(__tstate);
27057 if (PyErr_Occurred()) SWIG_fail;
27058 }
27059 {
27060 wxSize * resultptr;
27061 resultptr = new wxSize((wxSize &)(result));
27062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27063 }
27064 return resultobj;
27065 fail:
27066 return NULL;
27067 }
27068
27069
27070 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27071 PyObject *resultobj;
27072 wxWindow *arg1 = (wxWindow *) 0 ;
27073 int *arg2 = (int *) 0 ;
27074 int *arg3 = (int *) 0 ;
27075 int temp2 ;
27076 int res2 = 0 ;
27077 int temp3 ;
27078 int res3 = 0 ;
27079 PyObject * obj0 = 0 ;
27080 char *kwnames[] = {
27081 (char *) "self", NULL
27082 };
27083
27084 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27085 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27088 if (SWIG_arg_fail(1)) SWIG_fail;
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27092
27093 wxPyEndAllowThreads(__tstate);
27094 if (PyErr_Occurred()) SWIG_fail;
27095 }
27096 Py_INCREF(Py_None); resultobj = Py_None;
27097 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27098 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27099 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27100 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27101 return resultobj;
27102 fail:
27103 return NULL;
27104 }
27105
27106
27107 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27108 PyObject *resultobj;
27109 wxWindow *arg1 = (wxWindow *) 0 ;
27110 wxSize result;
27111 PyObject * obj0 = 0 ;
27112 char *kwnames[] = {
27113 (char *) "self", NULL
27114 };
27115
27116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27118 if (SWIG_arg_fail(1)) SWIG_fail;
27119 {
27120 PyThreadState* __tstate = wxPyBeginAllowThreads();
27121 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27122
27123 wxPyEndAllowThreads(__tstate);
27124 if (PyErr_Occurred()) SWIG_fail;
27125 }
27126 {
27127 wxSize * resultptr;
27128 resultptr = new wxSize((wxSize &)(result));
27129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27130 }
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27138 PyObject *resultobj;
27139 wxWindow *arg1 = (wxWindow *) 0 ;
27140 bool arg2 = (bool) true ;
27141 bool result;
27142 PyObject * obj0 = 0 ;
27143 PyObject * obj1 = 0 ;
27144 char *kwnames[] = {
27145 (char *) "self",(char *) "show", NULL
27146 };
27147
27148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27150 if (SWIG_arg_fail(1)) SWIG_fail;
27151 if (obj1) {
27152 {
27153 arg2 = (bool)(SWIG_As_bool(obj1));
27154 if (SWIG_arg_fail(2)) SWIG_fail;
27155 }
27156 }
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 result = (bool)(arg1)->Show(arg2);
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 {
27165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27166 }
27167 return resultobj;
27168 fail:
27169 return NULL;
27170 }
27171
27172
27173 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27174 PyObject *resultobj;
27175 wxWindow *arg1 = (wxWindow *) 0 ;
27176 bool result;
27177 PyObject * obj0 = 0 ;
27178 char *kwnames[] = {
27179 (char *) "self", NULL
27180 };
27181
27182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27184 if (SWIG_arg_fail(1)) SWIG_fail;
27185 {
27186 PyThreadState* __tstate = wxPyBeginAllowThreads();
27187 result = (bool)(arg1)->Hide();
27188
27189 wxPyEndAllowThreads(__tstate);
27190 if (PyErr_Occurred()) SWIG_fail;
27191 }
27192 {
27193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27194 }
27195 return resultobj;
27196 fail:
27197 return NULL;
27198 }
27199
27200
27201 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27202 PyObject *resultobj;
27203 wxWindow *arg1 = (wxWindow *) 0 ;
27204 bool arg2 = (bool) true ;
27205 bool result;
27206 PyObject * obj0 = 0 ;
27207 PyObject * obj1 = 0 ;
27208 char *kwnames[] = {
27209 (char *) "self",(char *) "enable", NULL
27210 };
27211
27212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27214 if (SWIG_arg_fail(1)) SWIG_fail;
27215 if (obj1) {
27216 {
27217 arg2 = (bool)(SWIG_As_bool(obj1));
27218 if (SWIG_arg_fail(2)) SWIG_fail;
27219 }
27220 }
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = (bool)(arg1)->Enable(arg2);
27224
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 {
27229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27230 }
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj;
27239 wxWindow *arg1 = (wxWindow *) 0 ;
27240 bool result;
27241 PyObject * obj0 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27248 if (SWIG_arg_fail(1)) SWIG_fail;
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 result = (bool)(arg1)->Disable();
27252
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 {
27257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27258 }
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 bool result;
27269 PyObject * obj0 = 0 ;
27270 char *kwnames[] = {
27271 (char *) "self", NULL
27272 };
27273
27274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(1)) SWIG_fail;
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 result = (bool)((wxWindow const *)arg1)->IsShown();
27280
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 {
27285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27286 }
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27294 PyObject *resultobj;
27295 wxWindow *arg1 = (wxWindow *) 0 ;
27296 bool result;
27297 PyObject * obj0 = 0 ;
27298 char *kwnames[] = {
27299 (char *) "self", NULL
27300 };
27301
27302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27304 if (SWIG_arg_fail(1)) SWIG_fail;
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 {
27313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27314 }
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27322 PyObject *resultobj;
27323 wxWindow *arg1 = (wxWindow *) 0 ;
27324 long arg2 ;
27325 PyObject * obj0 = 0 ;
27326 PyObject * obj1 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self",(char *) "style", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 {
27335 arg2 = (long)(SWIG_As_long(obj1));
27336 if (SWIG_arg_fail(2)) SWIG_fail;
27337 }
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 (arg1)->SetWindowStyleFlag(arg2);
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 Py_INCREF(Py_None); resultobj = Py_None;
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj;
27354 wxWindow *arg1 = (wxWindow *) 0 ;
27355 long result;
27356 PyObject * obj0 = 0 ;
27357 char *kwnames[] = {
27358 (char *) "self", NULL
27359 };
27360
27361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27363 if (SWIG_arg_fail(1)) SWIG_fail;
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27367
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 {
27372 resultobj = SWIG_From_long((long)(result));
27373 }
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27381 PyObject *resultobj;
27382 wxWindow *arg1 = (wxWindow *) 0 ;
27383 int arg2 ;
27384 bool result;
27385 PyObject * obj0 = 0 ;
27386 PyObject * obj1 = 0 ;
27387 char *kwnames[] = {
27388 (char *) "self",(char *) "flag", NULL
27389 };
27390
27391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 {
27395 arg2 = (int)(SWIG_As_int(obj1));
27396 if (SWIG_arg_fail(2)) SWIG_fail;
27397 }
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27401
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27415 PyObject *resultobj;
27416 wxWindow *arg1 = (wxWindow *) 0 ;
27417 bool result;
27418 PyObject * obj0 = 0 ;
27419 char *kwnames[] = {
27420 (char *) "self", NULL
27421 };
27422
27423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27425 if (SWIG_arg_fail(1)) SWIG_fail;
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = (bool)((wxWindow const *)arg1)->IsRetained();
27429
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27435 }
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27443 PyObject *resultobj;
27444 wxWindow *arg1 = (wxWindow *) 0 ;
27445 long arg2 ;
27446 PyObject * obj0 = 0 ;
27447 PyObject * obj1 = 0 ;
27448 char *kwnames[] = {
27449 (char *) "self",(char *) "exStyle", NULL
27450 };
27451
27452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) 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 arg2 = (long)(SWIG_As_long(obj1));
27457 if (SWIG_arg_fail(2)) SWIG_fail;
27458 }
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 (arg1)->SetExtraStyle(arg2);
27462
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 Py_INCREF(Py_None); resultobj = Py_None;
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27474 PyObject *resultobj;
27475 wxWindow *arg1 = (wxWindow *) 0 ;
27476 long result;
27477 PyObject * obj0 = 0 ;
27478 char *kwnames[] = {
27479 (char *) "self", NULL
27480 };
27481
27482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) 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 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = SWIG_From_long((long)(result));
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj;
27503 wxWindow *arg1 = (wxWindow *) 0 ;
27504 bool arg2 = (bool) true ;
27505 PyObject * obj0 = 0 ;
27506 PyObject * obj1 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self",(char *) "modal", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27513 if (SWIG_arg_fail(1)) SWIG_fail;
27514 if (obj1) {
27515 {
27516 arg2 = (bool)(SWIG_As_bool(obj1));
27517 if (SWIG_arg_fail(2)) SWIG_fail;
27518 }
27519 }
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 (arg1)->MakeModal(arg2);
27523
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 Py_INCREF(Py_None); resultobj = Py_None;
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxWindow *arg1 = (wxWindow *) 0 ;
27537 bool arg2 ;
27538 PyObject * obj0 = 0 ;
27539 PyObject * obj1 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "enableTheme", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 {
27548 arg2 = (bool)(SWIG_As_bool(obj1));
27549 if (SWIG_arg_fail(2)) SWIG_fail;
27550 }
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 (arg1)->SetThemeEnabled(arg2);
27554
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 Py_INCREF(Py_None); resultobj = Py_None;
27559 return resultobj;
27560 fail:
27561 return NULL;
27562 }
27563
27564
27565 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27566 PyObject *resultobj;
27567 wxWindow *arg1 = (wxWindow *) 0 ;
27568 bool result;
27569 PyObject * obj0 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27580
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 {
27585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27586 }
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 PyObject * obj0 = 0 ;
27597 char *kwnames[] = {
27598 (char *) "self", NULL
27599 };
27600
27601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27603 if (SWIG_arg_fail(1)) SWIG_fail;
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 (arg1)->SetFocus();
27607
27608 wxPyEndAllowThreads(__tstate);
27609 if (PyErr_Occurred()) SWIG_fail;
27610 }
27611 Py_INCREF(Py_None); resultobj = Py_None;
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27619 PyObject *resultobj;
27620 wxWindow *arg1 = (wxWindow *) 0 ;
27621 PyObject * obj0 = 0 ;
27622 char *kwnames[] = {
27623 (char *) "self", NULL
27624 };
27625
27626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27628 if (SWIG_arg_fail(1)) SWIG_fail;
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 (arg1)->SetFocusFromKbd();
27632
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 Py_INCREF(Py_None); resultobj = Py_None;
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27644 PyObject *resultobj;
27645 wxWindow *result;
27646 char *kwnames[] = {
27647 NULL
27648 };
27649
27650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27651 {
27652 if (!wxPyCheckForApp()) SWIG_fail;
27653 PyThreadState* __tstate = wxPyBeginAllowThreads();
27654 result = (wxWindow *)wxWindow::FindFocus();
27655
27656 wxPyEndAllowThreads(__tstate);
27657 if (PyErr_Occurred()) SWIG_fail;
27658 }
27659 {
27660 resultobj = wxPyMake_wxObject(result, 0);
27661 }
27662 return resultobj;
27663 fail:
27664 return NULL;
27665 }
27666
27667
27668 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27669 PyObject *resultobj;
27670 wxWindow *arg1 = (wxWindow *) 0 ;
27671 bool result;
27672 PyObject * obj0 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "self", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) 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 {
27681 PyThreadState* __tstate = wxPyBeginAllowThreads();
27682 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27683
27684 wxPyEndAllowThreads(__tstate);
27685 if (PyErr_Occurred()) SWIG_fail;
27686 }
27687 {
27688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27689 }
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj;
27698 wxWindow *arg1 = (wxWindow *) 0 ;
27699 bool result;
27700 PyObject * obj0 = 0 ;
27701 char *kwnames[] = {
27702 (char *) "self", NULL
27703 };
27704
27705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27707 if (SWIG_arg_fail(1)) SWIG_fail;
27708 {
27709 PyThreadState* __tstate = wxPyBeginAllowThreads();
27710 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27711
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 {
27716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27717 }
27718 return resultobj;
27719 fail:
27720 return NULL;
27721 }
27722
27723
27724 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27725 PyObject *resultobj;
27726 wxWindow *arg1 = (wxWindow *) 0 ;
27727 wxWindow *result;
27728 PyObject * obj0 = 0 ;
27729 char *kwnames[] = {
27730 (char *) "self", NULL
27731 };
27732
27733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27735 if (SWIG_arg_fail(1)) SWIG_fail;
27736 {
27737 PyThreadState* __tstate = wxPyBeginAllowThreads();
27738 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27739
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = wxPyMake_wxObject(result, 0);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj;
27754 wxWindow *arg1 = (wxWindow *) 0 ;
27755 wxWindow *arg2 = (wxWindow *) 0 ;
27756 wxWindow *result;
27757 PyObject * obj0 = 0 ;
27758 PyObject * obj1 = 0 ;
27759 char *kwnames[] = {
27760 (char *) "self",(char *) "child", NULL
27761 };
27762
27763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27765 if (SWIG_arg_fail(1)) SWIG_fail;
27766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27767 if (SWIG_arg_fail(2)) SWIG_fail;
27768 {
27769 PyThreadState* __tstate = wxPyBeginAllowThreads();
27770 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27771
27772 wxPyEndAllowThreads(__tstate);
27773 if (PyErr_Occurred()) SWIG_fail;
27774 }
27775 {
27776 resultobj = wxPyMake_wxObject(result, 0);
27777 }
27778 return resultobj;
27779 fail:
27780 return NULL;
27781 }
27782
27783
27784 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27785 PyObject *resultobj;
27786 wxWindow *arg1 = (wxWindow *) 0 ;
27787 wxWindow *arg2 = (wxWindow *) 0 ;
27788 PyObject * obj0 = 0 ;
27789 PyObject * obj1 = 0 ;
27790 char *kwnames[] = {
27791 (char *) "self",(char *) "win", NULL
27792 };
27793
27794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27796 if (SWIG_arg_fail(1)) SWIG_fail;
27797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27798 if (SWIG_arg_fail(2)) SWIG_fail;
27799 {
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 (arg1)->SetTmpDefaultItem(arg2);
27802
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 Py_INCREF(Py_None); resultobj = Py_None;
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj;
27815 wxWindow *arg1 = (wxWindow *) 0 ;
27816 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27817 bool result;
27818 PyObject * obj0 = 0 ;
27819 PyObject * obj1 = 0 ;
27820 char *kwnames[] = {
27821 (char *) "self",(char *) "flags", NULL
27822 };
27823
27824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27826 if (SWIG_arg_fail(1)) SWIG_fail;
27827 if (obj1) {
27828 {
27829 arg2 = (int)(SWIG_As_int(obj1));
27830 if (SWIG_arg_fail(2)) SWIG_fail;
27831 }
27832 }
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = (bool)(arg1)->Navigate(arg2);
27836
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 {
27841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27842 }
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27850 PyObject *resultobj;
27851 wxWindow *arg1 = (wxWindow *) 0 ;
27852 wxWindow *arg2 = (wxWindow *) 0 ;
27853 PyObject * obj0 = 0 ;
27854 PyObject * obj1 = 0 ;
27855 char *kwnames[] = {
27856 (char *) "self",(char *) "win", NULL
27857 };
27858
27859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27861 if (SWIG_arg_fail(1)) SWIG_fail;
27862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27863 if (SWIG_arg_fail(2)) SWIG_fail;
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 (arg1)->MoveAfterInTabOrder(arg2);
27867
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 Py_INCREF(Py_None); resultobj = Py_None;
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27879 PyObject *resultobj;
27880 wxWindow *arg1 = (wxWindow *) 0 ;
27881 wxWindow *arg2 = (wxWindow *) 0 ;
27882 PyObject * obj0 = 0 ;
27883 PyObject * obj1 = 0 ;
27884 char *kwnames[] = {
27885 (char *) "self",(char *) "win", NULL
27886 };
27887
27888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27890 if (SWIG_arg_fail(1)) SWIG_fail;
27891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27892 if (SWIG_arg_fail(2)) SWIG_fail;
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 (arg1)->MoveBeforeInTabOrder(arg2);
27896
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 Py_INCREF(Py_None); resultobj = Py_None;
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj;
27909 wxWindow *arg1 = (wxWindow *) 0 ;
27910 PyObject *result;
27911 PyObject * obj0 = 0 ;
27912 char *kwnames[] = {
27913 (char *) "self", NULL
27914 };
27915
27916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27918 if (SWIG_arg_fail(1)) SWIG_fail;
27919 {
27920 PyThreadState* __tstate = wxPyBeginAllowThreads();
27921 result = (PyObject *)wxWindow_GetChildren(arg1);
27922
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 resultobj = result;
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj;
27935 wxWindow *arg1 = (wxWindow *) 0 ;
27936 wxWindow *result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = wxPyMake_wxObject(result, 0);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 wxWindow *result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "self", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27972 if (SWIG_arg_fail(1)) SWIG_fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = wxPyMake_wxObject(result, 0);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj;
27991 wxWindow *arg1 = (wxWindow *) 0 ;
27992 bool result;
27993 PyObject * obj0 = 0 ;
27994 char *kwnames[] = {
27995 (char *) "self", NULL
27996 };
27997
27998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28000 if (SWIG_arg_fail(1)) SWIG_fail;
28001 {
28002 PyThreadState* __tstate = wxPyBeginAllowThreads();
28003 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28004
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 {
28009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28010 }
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj;
28019 wxWindow *arg1 = (wxWindow *) 0 ;
28020 wxWindow *arg2 = (wxWindow *) 0 ;
28021 bool result;
28022 PyObject * obj0 = 0 ;
28023 PyObject * obj1 = 0 ;
28024 char *kwnames[] = {
28025 (char *) "self",(char *) "newParent", NULL
28026 };
28027
28028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28030 if (SWIG_arg_fail(1)) SWIG_fail;
28031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28032 if (SWIG_arg_fail(2)) SWIG_fail;
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 result = (bool)(arg1)->Reparent(arg2);
28036
28037 wxPyEndAllowThreads(__tstate);
28038 if (PyErr_Occurred()) SWIG_fail;
28039 }
28040 {
28041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28042 }
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj;
28051 wxWindow *arg1 = (wxWindow *) 0 ;
28052 wxWindow *arg2 = (wxWindow *) 0 ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char *kwnames[] = {
28056 (char *) "self",(char *) "child", NULL
28057 };
28058
28059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(2)) SWIG_fail;
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 (arg1)->AddChild(arg2);
28067
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 Py_INCREF(Py_None); resultobj = Py_None;
28072 return resultobj;
28073 fail:
28074 return NULL;
28075 }
28076
28077
28078 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28079 PyObject *resultobj;
28080 wxWindow *arg1 = (wxWindow *) 0 ;
28081 wxWindow *arg2 = (wxWindow *) 0 ;
28082 PyObject * obj0 = 0 ;
28083 PyObject * obj1 = 0 ;
28084 char *kwnames[] = {
28085 (char *) "self",(char *) "child", NULL
28086 };
28087
28088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28090 if (SWIG_arg_fail(1)) SWIG_fail;
28091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28092 if (SWIG_arg_fail(2)) SWIG_fail;
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 (arg1)->RemoveChild(arg2);
28096
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 Py_INCREF(Py_None); resultobj = Py_None;
28101 return resultobj;
28102 fail:
28103 return NULL;
28104 }
28105
28106
28107 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28108 PyObject *resultobj;
28109 wxWindow *arg1 = (wxWindow *) 0 ;
28110 long arg2 ;
28111 wxWindow *result;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self",(char *) "winid", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",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 = (long)(SWIG_As_long(obj1));
28123 if (SWIG_arg_fail(2)) SWIG_fail;
28124 }
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (wxWindow *)(arg1)->FindWindow(arg2);
28128
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 {
28133 resultobj = wxPyMake_wxObject(result, 0);
28134 }
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28142 PyObject *resultobj;
28143 wxWindow *arg1 = (wxWindow *) 0 ;
28144 wxString *arg2 = 0 ;
28145 wxWindow *result;
28146 bool temp2 = false ;
28147 PyObject * obj0 = 0 ;
28148 PyObject * obj1 = 0 ;
28149 char *kwnames[] = {
28150 (char *) "self",(char *) "name", NULL
28151 };
28152
28153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 {
28157 arg2 = wxString_in_helper(obj1);
28158 if (arg2 == NULL) SWIG_fail;
28159 temp2 = true;
28160 }
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28164
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 {
28169 resultobj = wxPyMake_wxObject(result, 0);
28170 }
28171 {
28172 if (temp2)
28173 delete arg2;
28174 }
28175 return resultobj;
28176 fail:
28177 {
28178 if (temp2)
28179 delete arg2;
28180 }
28181 return NULL;
28182 }
28183
28184
28185 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28186 PyObject *resultobj;
28187 wxWindow *arg1 = (wxWindow *) 0 ;
28188 wxEvtHandler *result;
28189 PyObject * obj0 = 0 ;
28190 char *kwnames[] = {
28191 (char *) "self", NULL
28192 };
28193
28194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28196 if (SWIG_arg_fail(1)) SWIG_fail;
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 {
28205 resultobj = wxPyMake_wxObject(result, 0);
28206 }
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28214 PyObject *resultobj;
28215 wxWindow *arg1 = (wxWindow *) 0 ;
28216 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28217 PyObject * obj0 = 0 ;
28218 PyObject * obj1 = 0 ;
28219 char *kwnames[] = {
28220 (char *) "self",(char *) "handler", NULL
28221 };
28222
28223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28225 if (SWIG_arg_fail(1)) SWIG_fail;
28226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28227 if (SWIG_arg_fail(2)) SWIG_fail;
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 (arg1)->SetEventHandler(arg2);
28231
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 Py_INCREF(Py_None); resultobj = Py_None;
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28243 PyObject *resultobj;
28244 wxWindow *arg1 = (wxWindow *) 0 ;
28245 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28246 PyObject * obj0 = 0 ;
28247 PyObject * obj1 = 0 ;
28248 char *kwnames[] = {
28249 (char *) "self",(char *) "handler", NULL
28250 };
28251
28252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28254 if (SWIG_arg_fail(1)) SWIG_fail;
28255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28256 if (SWIG_arg_fail(2)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 (arg1)->PushEventHandler(arg2);
28260
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 Py_INCREF(Py_None); resultobj = Py_None;
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj;
28273 wxWindow *arg1 = (wxWindow *) 0 ;
28274 bool arg2 = (bool) false ;
28275 wxEvtHandler *result;
28276 PyObject * obj0 = 0 ;
28277 PyObject * obj1 = 0 ;
28278 char *kwnames[] = {
28279 (char *) "self",(char *) "deleteHandler", NULL
28280 };
28281
28282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28284 if (SWIG_arg_fail(1)) SWIG_fail;
28285 if (obj1) {
28286 {
28287 arg2 = (bool)(SWIG_As_bool(obj1));
28288 if (SWIG_arg_fail(2)) SWIG_fail;
28289 }
28290 }
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28294
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 {
28299 resultobj = wxPyMake_wxObject(result, 0);
28300 }
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28308 PyObject *resultobj;
28309 wxWindow *arg1 = (wxWindow *) 0 ;
28310 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28311 bool result;
28312 PyObject * obj0 = 0 ;
28313 PyObject * obj1 = 0 ;
28314 char *kwnames[] = {
28315 (char *) "self",(char *) "handler", NULL
28316 };
28317
28318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28320 if (SWIG_arg_fail(1)) SWIG_fail;
28321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28322 if (SWIG_arg_fail(2)) SWIG_fail;
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (bool)(arg1)->RemoveEventHandler(arg2);
28326
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 {
28331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28332 }
28333 return resultobj;
28334 fail:
28335 return NULL;
28336 }
28337
28338
28339 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28340 PyObject *resultobj;
28341 wxWindow *arg1 = (wxWindow *) 0 ;
28342 wxValidator *arg2 = 0 ;
28343 PyObject * obj0 = 0 ;
28344 PyObject * obj1 = 0 ;
28345 char *kwnames[] = {
28346 (char *) "self",(char *) "validator", NULL
28347 };
28348
28349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28351 if (SWIG_arg_fail(1)) SWIG_fail;
28352 {
28353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28354 if (SWIG_arg_fail(2)) SWIG_fail;
28355 if (arg2 == NULL) {
28356 SWIG_null_ref("wxValidator");
28357 }
28358 if (SWIG_arg_fail(2)) SWIG_fail;
28359 }
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 (arg1)->SetValidator((wxValidator const &)*arg2);
28363
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 Py_INCREF(Py_None); resultobj = Py_None;
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj;
28376 wxWindow *arg1 = (wxWindow *) 0 ;
28377 wxValidator *result;
28378 PyObject * obj0 = 0 ;
28379 char *kwnames[] = {
28380 (char *) "self", NULL
28381 };
28382
28383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28385 if (SWIG_arg_fail(1)) SWIG_fail;
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = (wxValidator *)(arg1)->GetValidator();
28389
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 {
28394 resultobj = wxPyMake_wxObject(result, 0);
28395 }
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28403 PyObject *resultobj;
28404 wxWindow *arg1 = (wxWindow *) 0 ;
28405 bool result;
28406 PyObject * obj0 = 0 ;
28407 char *kwnames[] = {
28408 (char *) "self", NULL
28409 };
28410
28411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28413 if (SWIG_arg_fail(1)) SWIG_fail;
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = (bool)(arg1)->Validate();
28417
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28423 }
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj;
28432 wxWindow *arg1 = (wxWindow *) 0 ;
28433 bool result;
28434 PyObject * obj0 = 0 ;
28435 char *kwnames[] = {
28436 (char *) "self", NULL
28437 };
28438
28439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28441 if (SWIG_arg_fail(1)) SWIG_fail;
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (bool)(arg1)->TransferDataToWindow();
28445
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28459 PyObject *resultobj;
28460 wxWindow *arg1 = (wxWindow *) 0 ;
28461 bool result;
28462 PyObject * obj0 = 0 ;
28463 char *kwnames[] = {
28464 (char *) "self", NULL
28465 };
28466
28467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28469 if (SWIG_arg_fail(1)) SWIG_fail;
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = (bool)(arg1)->TransferDataFromWindow();
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 {
28478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28479 }
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj;
28488 wxWindow *arg1 = (wxWindow *) 0 ;
28489 PyObject * obj0 = 0 ;
28490 char *kwnames[] = {
28491 (char *) "self", NULL
28492 };
28493
28494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28496 if (SWIG_arg_fail(1)) SWIG_fail;
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 (arg1)->InitDialog();
28500
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 Py_INCREF(Py_None); resultobj = Py_None;
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28512 PyObject *resultobj;
28513 wxWindow *arg1 = (wxWindow *) 0 ;
28514 wxAcceleratorTable *arg2 = 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 char *kwnames[] = {
28518 (char *) "self",(char *) "accel", NULL
28519 };
28520
28521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28523 if (SWIG_arg_fail(1)) SWIG_fail;
28524 {
28525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28526 if (SWIG_arg_fail(2)) SWIG_fail;
28527 if (arg2 == NULL) {
28528 SWIG_null_ref("wxAcceleratorTable");
28529 }
28530 if (SWIG_arg_fail(2)) SWIG_fail;
28531 }
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 Py_INCREF(Py_None); resultobj = Py_None;
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj;
28548 wxWindow *arg1 = (wxWindow *) 0 ;
28549 wxAcceleratorTable *result;
28550 PyObject * obj0 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28561
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj;
28574 wxWindow *arg1 = (wxWindow *) 0 ;
28575 int arg2 ;
28576 int arg3 ;
28577 int arg4 ;
28578 bool result;
28579 PyObject * obj0 = 0 ;
28580 PyObject * obj1 = 0 ;
28581 PyObject * obj2 = 0 ;
28582 PyObject * obj3 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 {
28591 arg2 = (int)(SWIG_As_int(obj1));
28592 if (SWIG_arg_fail(2)) SWIG_fail;
28593 }
28594 {
28595 arg3 = (int)(SWIG_As_int(obj2));
28596 if (SWIG_arg_fail(3)) SWIG_fail;
28597 }
28598 {
28599 arg4 = (int)(SWIG_As_int(obj3));
28600 if (SWIG_arg_fail(4)) SWIG_fail;
28601 }
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj;
28620 wxWindow *arg1 = (wxWindow *) 0 ;
28621 int arg2 ;
28622 bool result;
28623 PyObject * obj0 = 0 ;
28624 PyObject * obj1 = 0 ;
28625 char *kwnames[] = {
28626 (char *) "self",(char *) "hotkeyId", NULL
28627 };
28628
28629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28631 if (SWIG_arg_fail(1)) SWIG_fail;
28632 {
28633 arg2 = (int)(SWIG_As_int(obj1));
28634 if (SWIG_arg_fail(2)) SWIG_fail;
28635 }
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28639
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 {
28644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28645 }
28646 return resultobj;
28647 fail:
28648 return NULL;
28649 }
28650
28651
28652 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28653 PyObject *resultobj;
28654 wxWindow *arg1 = (wxWindow *) 0 ;
28655 wxPoint *arg2 = 0 ;
28656 wxPoint result;
28657 wxPoint temp2 ;
28658 PyObject * obj0 = 0 ;
28659 PyObject * obj1 = 0 ;
28660 char *kwnames[] = {
28661 (char *) "self",(char *) "pt", NULL
28662 };
28663
28664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28666 if (SWIG_arg_fail(1)) SWIG_fail;
28667 {
28668 arg2 = &temp2;
28669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28670 }
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28674
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 {
28679 wxPoint * resultptr;
28680 resultptr = new wxPoint((wxPoint &)(result));
28681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28682 }
28683 return resultobj;
28684 fail:
28685 return NULL;
28686 }
28687
28688
28689 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28690 PyObject *resultobj;
28691 wxWindow *arg1 = (wxWindow *) 0 ;
28692 wxSize *arg2 = 0 ;
28693 wxSize result;
28694 wxSize temp2 ;
28695 PyObject * obj0 = 0 ;
28696 PyObject * obj1 = 0 ;
28697 char *kwnames[] = {
28698 (char *) "self",(char *) "sz", NULL
28699 };
28700
28701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28703 if (SWIG_arg_fail(1)) SWIG_fail;
28704 {
28705 arg2 = &temp2;
28706 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28707 }
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28711
28712 wxPyEndAllowThreads(__tstate);
28713 if (PyErr_Occurred()) SWIG_fail;
28714 }
28715 {
28716 wxSize * resultptr;
28717 resultptr = new wxSize((wxSize &)(result));
28718 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28719 }
28720 return resultobj;
28721 fail:
28722 return NULL;
28723 }
28724
28725
28726 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28727 PyObject *resultobj;
28728 wxWindow *arg1 = (wxWindow *) 0 ;
28729 wxPoint *arg2 = 0 ;
28730 wxPoint result;
28731 wxPoint temp2 ;
28732 PyObject * obj0 = 0 ;
28733 PyObject * obj1 = 0 ;
28734 char *kwnames[] = {
28735 (char *) "self",(char *) "pt", NULL
28736 };
28737
28738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 {
28742 arg2 = &temp2;
28743 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28744 }
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28748
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 {
28753 wxPoint * resultptr;
28754 resultptr = new wxPoint((wxPoint &)(result));
28755 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28756 }
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj;
28765 wxWindow *arg1 = (wxWindow *) 0 ;
28766 wxSize *arg2 = 0 ;
28767 wxSize result;
28768 wxSize temp2 ;
28769 PyObject * obj0 = 0 ;
28770 PyObject * obj1 = 0 ;
28771 char *kwnames[] = {
28772 (char *) "self",(char *) "sz", NULL
28773 };
28774
28775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28777 if (SWIG_arg_fail(1)) SWIG_fail;
28778 {
28779 arg2 = &temp2;
28780 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28781 }
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28785
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 {
28790 wxSize * resultptr;
28791 resultptr = new wxSize((wxSize &)(result));
28792 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28793 }
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28801 PyObject *resultobj;
28802 wxWindow *arg1 = (wxWindow *) 0 ;
28803 wxPoint *arg2 = 0 ;
28804 wxPoint result;
28805 wxPoint temp2 ;
28806 PyObject * obj0 = 0 ;
28807 PyObject * obj1 = 0 ;
28808 char *kwnames[] = {
28809 (char *) "self",(char *) "pt", NULL
28810 };
28811
28812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 {
28816 arg2 = &temp2;
28817 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28818 }
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28822
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 {
28827 wxPoint * resultptr;
28828 resultptr = new wxPoint((wxPoint &)(result));
28829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28830 }
28831 return resultobj;
28832 fail:
28833 return NULL;
28834 }
28835
28836
28837 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj;
28839 wxWindow *arg1 = (wxWindow *) 0 ;
28840 wxSize *arg2 = 0 ;
28841 wxSize result;
28842 wxSize temp2 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 char *kwnames[] = {
28846 (char *) "self",(char *) "sz", NULL
28847 };
28848
28849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(1)) SWIG_fail;
28852 {
28853 arg2 = &temp2;
28854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28855 }
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28859
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 {
28864 wxSize * resultptr;
28865 resultptr = new wxSize((wxSize &)(result));
28866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28867 }
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28875 PyObject *resultobj;
28876 wxWindow *arg1 = (wxWindow *) 0 ;
28877 int arg2 ;
28878 int arg3 ;
28879 PyObject * obj0 = 0 ;
28880 PyObject * obj1 = 0 ;
28881 PyObject * obj2 = 0 ;
28882 char *kwnames[] = {
28883 (char *) "self",(char *) "x",(char *) "y", NULL
28884 };
28885
28886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28888 if (SWIG_arg_fail(1)) SWIG_fail;
28889 {
28890 arg2 = (int)(SWIG_As_int(obj1));
28891 if (SWIG_arg_fail(2)) SWIG_fail;
28892 }
28893 {
28894 arg3 = (int)(SWIG_As_int(obj2));
28895 if (SWIG_arg_fail(3)) SWIG_fail;
28896 }
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 (arg1)->WarpPointer(arg2,arg3);
28900
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 Py_INCREF(Py_None); resultobj = Py_None;
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28912 PyObject *resultobj;
28913 wxWindow *arg1 = (wxWindow *) 0 ;
28914 PyObject * obj0 = 0 ;
28915 char *kwnames[] = {
28916 (char *) "self", NULL
28917 };
28918
28919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28921 if (SWIG_arg_fail(1)) SWIG_fail;
28922 {
28923 PyThreadState* __tstate = wxPyBeginAllowThreads();
28924 (arg1)->CaptureMouse();
28925
28926 wxPyEndAllowThreads(__tstate);
28927 if (PyErr_Occurred()) SWIG_fail;
28928 }
28929 Py_INCREF(Py_None); resultobj = Py_None;
28930 return resultobj;
28931 fail:
28932 return NULL;
28933 }
28934
28935
28936 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28937 PyObject *resultobj;
28938 wxWindow *arg1 = (wxWindow *) 0 ;
28939 PyObject * obj0 = 0 ;
28940 char *kwnames[] = {
28941 (char *) "self", NULL
28942 };
28943
28944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28946 if (SWIG_arg_fail(1)) SWIG_fail;
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 (arg1)->ReleaseMouse();
28950
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 Py_INCREF(Py_None); resultobj = Py_None;
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28962 PyObject *resultobj;
28963 wxWindow *result;
28964 char *kwnames[] = {
28965 NULL
28966 };
28967
28968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28969 {
28970 if (!wxPyCheckForApp()) SWIG_fail;
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (wxWindow *)wxWindow::GetCapture();
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 {
28978 resultobj = wxPyMake_wxObject(result, 0);
28979 }
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj;
28988 wxWindow *arg1 = (wxWindow *) 0 ;
28989 bool result;
28990 PyObject * obj0 = 0 ;
28991 char *kwnames[] = {
28992 (char *) "self", NULL
28993 };
28994
28995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28997 if (SWIG_arg_fail(1)) SWIG_fail;
28998 {
28999 PyThreadState* __tstate = wxPyBeginAllowThreads();
29000 result = (bool)((wxWindow const *)arg1)->HasCapture();
29001
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 {
29006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29007 }
29008 return resultobj;
29009 fail:
29010 return NULL;
29011 }
29012
29013
29014 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29015 PyObject *resultobj;
29016 wxWindow *arg1 = (wxWindow *) 0 ;
29017 bool arg2 = (bool) true ;
29018 wxRect *arg3 = (wxRect *) NULL ;
29019 PyObject * obj0 = 0 ;
29020 PyObject * obj1 = 0 ;
29021 PyObject * obj2 = 0 ;
29022 char *kwnames[] = {
29023 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29024 };
29025
29026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29028 if (SWIG_arg_fail(1)) SWIG_fail;
29029 if (obj1) {
29030 {
29031 arg2 = (bool)(SWIG_As_bool(obj1));
29032 if (SWIG_arg_fail(2)) SWIG_fail;
29033 }
29034 }
29035 if (obj2) {
29036 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29037 if (SWIG_arg_fail(3)) SWIG_fail;
29038 }
29039 {
29040 PyThreadState* __tstate = wxPyBeginAllowThreads();
29041 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29042
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 Py_INCREF(Py_None); resultobj = Py_None;
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29054 PyObject *resultobj;
29055 wxWindow *arg1 = (wxWindow *) 0 ;
29056 wxRect *arg2 = 0 ;
29057 bool arg3 = (bool) true ;
29058 wxRect temp2 ;
29059 PyObject * obj0 = 0 ;
29060 PyObject * obj1 = 0 ;
29061 PyObject * obj2 = 0 ;
29062 char *kwnames[] = {
29063 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29064 };
29065
29066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29068 if (SWIG_arg_fail(1)) SWIG_fail;
29069 {
29070 arg2 = &temp2;
29071 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29072 }
29073 if (obj2) {
29074 {
29075 arg3 = (bool)(SWIG_As_bool(obj2));
29076 if (SWIG_arg_fail(3)) SWIG_fail;
29077 }
29078 }
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 Py_INCREF(Py_None); resultobj = Py_None;
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29094 PyObject *resultobj;
29095 wxWindow *arg1 = (wxWindow *) 0 ;
29096 PyObject * obj0 = 0 ;
29097 char *kwnames[] = {
29098 (char *) "self", NULL
29099 };
29100
29101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29103 if (SWIG_arg_fail(1)) SWIG_fail;
29104 {
29105 PyThreadState* __tstate = wxPyBeginAllowThreads();
29106 (arg1)->Update();
29107
29108 wxPyEndAllowThreads(__tstate);
29109 if (PyErr_Occurred()) SWIG_fail;
29110 }
29111 Py_INCREF(Py_None); resultobj = Py_None;
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj;
29120 wxWindow *arg1 = (wxWindow *) 0 ;
29121 PyObject * obj0 = 0 ;
29122 char *kwnames[] = {
29123 (char *) "self", NULL
29124 };
29125
29126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29128 if (SWIG_arg_fail(1)) SWIG_fail;
29129 {
29130 PyThreadState* __tstate = wxPyBeginAllowThreads();
29131 (arg1)->ClearBackground();
29132
29133 wxPyEndAllowThreads(__tstate);
29134 if (PyErr_Occurred()) SWIG_fail;
29135 }
29136 Py_INCREF(Py_None); resultobj = Py_None;
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29144 PyObject *resultobj;
29145 wxWindow *arg1 = (wxWindow *) 0 ;
29146 PyObject * obj0 = 0 ;
29147 char *kwnames[] = {
29148 (char *) "self", NULL
29149 };
29150
29151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29153 if (SWIG_arg_fail(1)) SWIG_fail;
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 (arg1)->Freeze();
29157
29158 wxPyEndAllowThreads(__tstate);
29159 if (PyErr_Occurred()) SWIG_fail;
29160 }
29161 Py_INCREF(Py_None); resultobj = Py_None;
29162 return resultobj;
29163 fail:
29164 return NULL;
29165 }
29166
29167
29168 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29169 PyObject *resultobj;
29170 wxWindow *arg1 = (wxWindow *) 0 ;
29171 PyObject * obj0 = 0 ;
29172 char *kwnames[] = {
29173 (char *) "self", NULL
29174 };
29175
29176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29178 if (SWIG_arg_fail(1)) SWIG_fail;
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 (arg1)->Thaw();
29182
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 Py_INCREF(Py_None); resultobj = Py_None;
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29194 PyObject *resultobj;
29195 wxWindow *arg1 = (wxWindow *) 0 ;
29196 wxDC *arg2 = 0 ;
29197 PyObject * obj0 = 0 ;
29198 PyObject * obj1 = 0 ;
29199 char *kwnames[] = {
29200 (char *) "self",(char *) "dc", NULL
29201 };
29202
29203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29205 if (SWIG_arg_fail(1)) SWIG_fail;
29206 {
29207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29208 if (SWIG_arg_fail(2)) SWIG_fail;
29209 if (arg2 == NULL) {
29210 SWIG_null_ref("wxDC");
29211 }
29212 if (SWIG_arg_fail(2)) SWIG_fail;
29213 }
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 (arg1)->PrepareDC(*arg2);
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 Py_INCREF(Py_None); resultobj = Py_None;
29222 return resultobj;
29223 fail:
29224 return NULL;
29225 }
29226
29227
29228 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj;
29230 wxWindow *arg1 = (wxWindow *) 0 ;
29231 wxRegion *result;
29232 PyObject * obj0 = 0 ;
29233 char *kwnames[] = {
29234 (char *) "self", NULL
29235 };
29236
29237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29239 if (SWIG_arg_fail(1)) SWIG_fail;
29240 {
29241 PyThreadState* __tstate = wxPyBeginAllowThreads();
29242 {
29243 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29244 result = (wxRegion *) &_result_ref;
29245 }
29246
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29258 PyObject *resultobj;
29259 wxWindow *arg1 = (wxWindow *) 0 ;
29260 wxRect result;
29261 PyObject * obj0 = 0 ;
29262 char *kwnames[] = {
29263 (char *) "self", NULL
29264 };
29265
29266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29268 if (SWIG_arg_fail(1)) SWIG_fail;
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29272
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 {
29277 wxRect * resultptr;
29278 resultptr = new wxRect((wxRect &)(result));
29279 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29280 }
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29288 PyObject *resultobj;
29289 wxWindow *arg1 = (wxWindow *) 0 ;
29290 int arg2 ;
29291 int arg3 ;
29292 int arg4 = (int) 1 ;
29293 int arg5 = (int) 1 ;
29294 bool result;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 PyObject * obj2 = 0 ;
29298 PyObject * obj3 = 0 ;
29299 PyObject * obj4 = 0 ;
29300 char *kwnames[] = {
29301 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29302 };
29303
29304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29306 if (SWIG_arg_fail(1)) SWIG_fail;
29307 {
29308 arg2 = (int)(SWIG_As_int(obj1));
29309 if (SWIG_arg_fail(2)) SWIG_fail;
29310 }
29311 {
29312 arg3 = (int)(SWIG_As_int(obj2));
29313 if (SWIG_arg_fail(3)) SWIG_fail;
29314 }
29315 if (obj3) {
29316 {
29317 arg4 = (int)(SWIG_As_int(obj3));
29318 if (SWIG_arg_fail(4)) SWIG_fail;
29319 }
29320 }
29321 if (obj4) {
29322 {
29323 arg5 = (int)(SWIG_As_int(obj4));
29324 if (SWIG_arg_fail(5)) SWIG_fail;
29325 }
29326 }
29327 {
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29330
29331 wxPyEndAllowThreads(__tstate);
29332 if (PyErr_Occurred()) SWIG_fail;
29333 }
29334 {
29335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29336 }
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj;
29345 wxWindow *arg1 = (wxWindow *) 0 ;
29346 wxPoint *arg2 = 0 ;
29347 bool result;
29348 wxPoint temp2 ;
29349 PyObject * obj0 = 0 ;
29350 PyObject * obj1 = 0 ;
29351 char *kwnames[] = {
29352 (char *) "self",(char *) "pt", NULL
29353 };
29354
29355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29357 if (SWIG_arg_fail(1)) SWIG_fail;
29358 {
29359 arg2 = &temp2;
29360 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29361 }
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 {
29370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29371 }
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj;
29380 wxWindow *arg1 = (wxWindow *) 0 ;
29381 wxRect *arg2 = 0 ;
29382 bool result;
29383 wxRect temp2 ;
29384 PyObject * obj0 = 0 ;
29385 PyObject * obj1 = 0 ;
29386 char *kwnames[] = {
29387 (char *) "self",(char *) "rect", NULL
29388 };
29389
29390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29392 if (SWIG_arg_fail(1)) SWIG_fail;
29393 {
29394 arg2 = &temp2;
29395 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29396 }
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 {
29405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29406 }
29407 return resultobj;
29408 fail:
29409 return NULL;
29410 }
29411
29412
29413 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29414 PyObject *resultobj;
29415 wxWindow *arg1 = (wxWindow *) 0 ;
29416 wxVisualAttributes result;
29417 PyObject * obj0 = 0 ;
29418 char *kwnames[] = {
29419 (char *) "self", NULL
29420 };
29421
29422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29424 if (SWIG_arg_fail(1)) SWIG_fail;
29425 {
29426 PyThreadState* __tstate = wxPyBeginAllowThreads();
29427 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29428
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 {
29433 wxVisualAttributes * resultptr;
29434 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29436 }
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29444 PyObject *resultobj;
29445 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29446 wxVisualAttributes result;
29447 PyObject * obj0 = 0 ;
29448 char *kwnames[] = {
29449 (char *) "variant", NULL
29450 };
29451
29452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29453 if (obj0) {
29454 {
29455 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29456 if (SWIG_arg_fail(1)) SWIG_fail;
29457 }
29458 }
29459 {
29460 if (!wxPyCheckForApp()) SWIG_fail;
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 wxVisualAttributes * resultptr;
29469 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29471 }
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj;
29480 wxWindow *arg1 = (wxWindow *) 0 ;
29481 wxColour *arg2 = 0 ;
29482 bool result;
29483 wxColour temp2 ;
29484 PyObject * obj0 = 0 ;
29485 PyObject * obj1 = 0 ;
29486 char *kwnames[] = {
29487 (char *) "self",(char *) "colour", NULL
29488 };
29489
29490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29492 if (SWIG_arg_fail(1)) SWIG_fail;
29493 {
29494 arg2 = &temp2;
29495 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29496 }
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29500
29501 wxPyEndAllowThreads(__tstate);
29502 if (PyErr_Occurred()) SWIG_fail;
29503 }
29504 {
29505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29506 }
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj;
29515 wxWindow *arg1 = (wxWindow *) 0 ;
29516 wxColour *arg2 = 0 ;
29517 wxColour temp2 ;
29518 PyObject * obj0 = 0 ;
29519 PyObject * obj1 = 0 ;
29520 char *kwnames[] = {
29521 (char *) "self",(char *) "colour", NULL
29522 };
29523
29524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29526 if (SWIG_arg_fail(1)) SWIG_fail;
29527 {
29528 arg2 = &temp2;
29529 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29530 }
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 Py_INCREF(Py_None); resultobj = Py_None;
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj;
29547 wxWindow *arg1 = (wxWindow *) 0 ;
29548 wxColour *arg2 = 0 ;
29549 bool result;
29550 wxColour temp2 ;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 char *kwnames[] = {
29554 (char *) "self",(char *) "colour", NULL
29555 };
29556
29557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29559 if (SWIG_arg_fail(1)) SWIG_fail;
29560 {
29561 arg2 = &temp2;
29562 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29567
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 {
29572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29573 }
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxWindow *arg1 = (wxWindow *) 0 ;
29583 wxColour *arg2 = 0 ;
29584 wxColour temp2 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 char *kwnames[] = {
29588 (char *) "self",(char *) "colour", NULL
29589 };
29590
29591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29593 if (SWIG_arg_fail(1)) SWIG_fail;
29594 {
29595 arg2 = &temp2;
29596 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29597 }
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 Py_INCREF(Py_None); resultobj = Py_None;
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj;
29614 wxWindow *arg1 = (wxWindow *) 0 ;
29615 wxColour result;
29616 PyObject * obj0 = 0 ;
29617 char *kwnames[] = {
29618 (char *) "self", NULL
29619 };
29620
29621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29623 if (SWIG_arg_fail(1)) SWIG_fail;
29624 {
29625 PyThreadState* __tstate = wxPyBeginAllowThreads();
29626 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29627
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 {
29632 wxColour * resultptr;
29633 resultptr = new wxColour((wxColour &)(result));
29634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29635 }
29636 return resultobj;
29637 fail:
29638 return NULL;
29639 }
29640
29641
29642 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29643 PyObject *resultobj;
29644 wxWindow *arg1 = (wxWindow *) 0 ;
29645 wxColour result;
29646 PyObject * obj0 = 0 ;
29647 char *kwnames[] = {
29648 (char *) "self", NULL
29649 };
29650
29651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29653 if (SWIG_arg_fail(1)) SWIG_fail;
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 result = ((wxWindow const *)arg1)->GetForegroundColour();
29657
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 {
29662 wxColour * resultptr;
29663 resultptr = new wxColour((wxColour &)(result));
29664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29665 }
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29673 PyObject *resultobj;
29674 wxWindow *arg1 = (wxWindow *) 0 ;
29675 bool result;
29676 PyObject * obj0 = 0 ;
29677 char *kwnames[] = {
29678 (char *) "self", NULL
29679 };
29680
29681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 {
29692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29693 }
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29701 PyObject *resultobj;
29702 wxWindow *arg1 = (wxWindow *) 0 ;
29703 bool result;
29704 PyObject * obj0 = 0 ;
29705 char *kwnames[] = {
29706 (char *) "self", NULL
29707 };
29708
29709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29711 if (SWIG_arg_fail(1)) SWIG_fail;
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 {
29720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29721 }
29722 return resultobj;
29723 fail:
29724 return NULL;
29725 }
29726
29727
29728 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29729 PyObject *resultobj;
29730 wxWindow *arg1 = (wxWindow *) 0 ;
29731 wxBackgroundStyle arg2 ;
29732 bool result;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 char *kwnames[] = {
29736 (char *) "self",(char *) "style", NULL
29737 };
29738
29739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29741 if (SWIG_arg_fail(1)) SWIG_fail;
29742 {
29743 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29744 if (SWIG_arg_fail(2)) SWIG_fail;
29745 }
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29749
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 {
29754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29755 }
29756 return resultobj;
29757 fail:
29758 return NULL;
29759 }
29760
29761
29762 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29763 PyObject *resultobj;
29764 wxWindow *arg1 = (wxWindow *) 0 ;
29765 wxBackgroundStyle result;
29766 PyObject * obj0 = 0 ;
29767 char *kwnames[] = {
29768 (char *) "self", NULL
29769 };
29770
29771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29773 if (SWIG_arg_fail(1)) SWIG_fail;
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29777
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 resultobj = SWIG_From_int((result));
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29789 PyObject *resultobj;
29790 wxWindow *arg1 = (wxWindow *) 0 ;
29791 bool result;
29792 PyObject * obj0 = 0 ;
29793 char *kwnames[] = {
29794 (char *) "self", NULL
29795 };
29796
29797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29799 if (SWIG_arg_fail(1)) SWIG_fail;
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 result = (bool)(arg1)->HasTransparentBackground();
29803
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 {
29808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29809 }
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29817 PyObject *resultobj;
29818 wxWindow *arg1 = (wxWindow *) 0 ;
29819 wxCursor *arg2 = 0 ;
29820 bool result;
29821 PyObject * obj0 = 0 ;
29822 PyObject * obj1 = 0 ;
29823 char *kwnames[] = {
29824 (char *) "self",(char *) "cursor", NULL
29825 };
29826
29827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29829 if (SWIG_arg_fail(1)) SWIG_fail;
29830 {
29831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29832 if (SWIG_arg_fail(2)) SWIG_fail;
29833 if (arg2 == NULL) {
29834 SWIG_null_ref("wxCursor");
29835 }
29836 if (SWIG_arg_fail(2)) SWIG_fail;
29837 }
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29841
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 {
29846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29847 }
29848 return resultobj;
29849 fail:
29850 return NULL;
29851 }
29852
29853
29854 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29855 PyObject *resultobj;
29856 wxWindow *arg1 = (wxWindow *) 0 ;
29857 wxCursor result;
29858 PyObject * obj0 = 0 ;
29859 char *kwnames[] = {
29860 (char *) "self", NULL
29861 };
29862
29863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29865 if (SWIG_arg_fail(1)) SWIG_fail;
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 result = (arg1)->GetCursor();
29869
29870 wxPyEndAllowThreads(__tstate);
29871 if (PyErr_Occurred()) SWIG_fail;
29872 }
29873 {
29874 wxCursor * resultptr;
29875 resultptr = new wxCursor((wxCursor &)(result));
29876 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29877 }
29878 return resultobj;
29879 fail:
29880 return NULL;
29881 }
29882
29883
29884 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29885 PyObject *resultobj;
29886 wxWindow *arg1 = (wxWindow *) 0 ;
29887 wxFont *arg2 = 0 ;
29888 bool result;
29889 PyObject * obj0 = 0 ;
29890 PyObject * obj1 = 0 ;
29891 char *kwnames[] = {
29892 (char *) "self",(char *) "font", NULL
29893 };
29894
29895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29897 if (SWIG_arg_fail(1)) SWIG_fail;
29898 {
29899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29900 if (SWIG_arg_fail(2)) SWIG_fail;
29901 if (arg2 == NULL) {
29902 SWIG_null_ref("wxFont");
29903 }
29904 if (SWIG_arg_fail(2)) SWIG_fail;
29905 }
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29909
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 {
29914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29915 }
29916 return resultobj;
29917 fail:
29918 return NULL;
29919 }
29920
29921
29922 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29923 PyObject *resultobj;
29924 wxWindow *arg1 = (wxWindow *) 0 ;
29925 wxFont *arg2 = 0 ;
29926 PyObject * obj0 = 0 ;
29927 PyObject * obj1 = 0 ;
29928 char *kwnames[] = {
29929 (char *) "self",(char *) "font", NULL
29930 };
29931
29932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29934 if (SWIG_arg_fail(1)) SWIG_fail;
29935 {
29936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29937 if (SWIG_arg_fail(2)) SWIG_fail;
29938 if (arg2 == NULL) {
29939 SWIG_null_ref("wxFont");
29940 }
29941 if (SWIG_arg_fail(2)) SWIG_fail;
29942 }
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 (arg1)->SetOwnFont((wxFont const &)*arg2);
29946
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 Py_INCREF(Py_None); resultobj = Py_None;
29951 return resultobj;
29952 fail:
29953 return NULL;
29954 }
29955
29956
29957 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29958 PyObject *resultobj;
29959 wxWindow *arg1 = (wxWindow *) 0 ;
29960 wxFont result;
29961 PyObject * obj0 = 0 ;
29962 char *kwnames[] = {
29963 (char *) "self", NULL
29964 };
29965
29966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29968 if (SWIG_arg_fail(1)) SWIG_fail;
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 result = (arg1)->GetFont();
29972
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 {
29977 wxFont * resultptr;
29978 resultptr = new wxFont((wxFont &)(result));
29979 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj;
29989 wxWindow *arg1 = (wxWindow *) 0 ;
29990 wxCaret *arg2 = (wxCaret *) 0 ;
29991 PyObject * obj0 = 0 ;
29992 PyObject * obj1 = 0 ;
29993 char *kwnames[] = {
29994 (char *) "self",(char *) "caret", NULL
29995 };
29996
29997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29999 if (SWIG_arg_fail(1)) SWIG_fail;
30000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(2)) SWIG_fail;
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 (arg1)->SetCaret(arg2);
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 Py_INCREF(Py_None); resultobj = Py_None;
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj;
30018 wxWindow *arg1 = (wxWindow *) 0 ;
30019 wxCaret *result;
30020 PyObject * obj0 = 0 ;
30021 char *kwnames[] = {
30022 (char *) "self", NULL
30023 };
30024
30025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(1)) SWIG_fail;
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30031
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30036 return resultobj;
30037 fail:
30038 return NULL;
30039 }
30040
30041
30042 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30043 PyObject *resultobj;
30044 wxWindow *arg1 = (wxWindow *) 0 ;
30045 int result;
30046 PyObject * obj0 = 0 ;
30047 char *kwnames[] = {
30048 (char *) "self", NULL
30049 };
30050
30051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30053 if (SWIG_arg_fail(1)) SWIG_fail;
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30057
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 {
30062 resultobj = SWIG_From_int((int)(result));
30063 }
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30071 PyObject *resultobj;
30072 wxWindow *arg1 = (wxWindow *) 0 ;
30073 int result;
30074 PyObject * obj0 = 0 ;
30075 char *kwnames[] = {
30076 (char *) "self", NULL
30077 };
30078
30079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30081 if (SWIG_arg_fail(1)) SWIG_fail;
30082 {
30083 PyThreadState* __tstate = wxPyBeginAllowThreads();
30084 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30085
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 {
30090 resultobj = SWIG_From_int((int)(result));
30091 }
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj;
30100 wxWindow *arg1 = (wxWindow *) 0 ;
30101 wxString *arg2 = 0 ;
30102 int *arg3 = (int *) 0 ;
30103 int *arg4 = (int *) 0 ;
30104 bool temp2 = false ;
30105 int temp3 ;
30106 int res3 = 0 ;
30107 int temp4 ;
30108 int res4 = 0 ;
30109 PyObject * obj0 = 0 ;
30110 PyObject * obj1 = 0 ;
30111 char *kwnames[] = {
30112 (char *) "self",(char *) "string", NULL
30113 };
30114
30115 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30116 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30119 if (SWIG_arg_fail(1)) SWIG_fail;
30120 {
30121 arg2 = wxString_in_helper(obj1);
30122 if (arg2 == NULL) SWIG_fail;
30123 temp2 = true;
30124 }
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 Py_INCREF(Py_None); resultobj = Py_None;
30133 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30134 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30135 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30136 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30137 {
30138 if (temp2)
30139 delete arg2;
30140 }
30141 return resultobj;
30142 fail:
30143 {
30144 if (temp2)
30145 delete arg2;
30146 }
30147 return NULL;
30148 }
30149
30150
30151 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30152 PyObject *resultobj;
30153 wxWindow *arg1 = (wxWindow *) 0 ;
30154 wxString *arg2 = 0 ;
30155 int *arg3 = (int *) 0 ;
30156 int *arg4 = (int *) 0 ;
30157 int *arg5 = (int *) 0 ;
30158 int *arg6 = (int *) 0 ;
30159 wxFont *arg7 = (wxFont *) NULL ;
30160 bool temp2 = false ;
30161 int temp3 ;
30162 int res3 = 0 ;
30163 int temp4 ;
30164 int res4 = 0 ;
30165 int temp5 ;
30166 int res5 = 0 ;
30167 int temp6 ;
30168 int res6 = 0 ;
30169 PyObject * obj0 = 0 ;
30170 PyObject * obj1 = 0 ;
30171 PyObject * obj2 = 0 ;
30172 char *kwnames[] = {
30173 (char *) "self",(char *) "string",(char *) "font", NULL
30174 };
30175
30176 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30177 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30178 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30179 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = wxString_in_helper(obj1);
30185 if (arg2 == NULL) SWIG_fail;
30186 temp2 = true;
30187 }
30188 if (obj2) {
30189 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30190 if (SWIG_arg_fail(7)) SWIG_fail;
30191 }
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30195
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 Py_INCREF(Py_None); resultobj = Py_None;
30200 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30201 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30202 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30203 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30204 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30205 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30206 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30207 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30208 {
30209 if (temp2)
30210 delete arg2;
30211 }
30212 return resultobj;
30213 fail:
30214 {
30215 if (temp2)
30216 delete arg2;
30217 }
30218 return NULL;
30219 }
30220
30221
30222 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30223 PyObject *resultobj;
30224 wxWindow *arg1 = (wxWindow *) 0 ;
30225 int *arg2 = (int *) 0 ;
30226 int *arg3 = (int *) 0 ;
30227 int temp2 ;
30228 int res2 = 0 ;
30229 int temp3 ;
30230 int res3 = 0 ;
30231 PyObject * obj0 = 0 ;
30232 PyObject * obj1 = 0 ;
30233 PyObject * obj2 = 0 ;
30234 char *kwnames[] = {
30235 (char *) "self",(char *) "x",(char *) "y", NULL
30236 };
30237
30238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30240 if (SWIG_arg_fail(1)) SWIG_fail;
30241 {
30242 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30243 temp2 = SWIG_As_int(obj1);
30244 if (SWIG_arg_fail(2)) SWIG_fail;
30245 arg2 = &temp2;
30246 res2 = SWIG_NEWOBJ;
30247 }
30248 }
30249 {
30250 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30251 temp3 = SWIG_As_int(obj2);
30252 if (SWIG_arg_fail(3)) SWIG_fail;
30253 arg3 = &temp3;
30254 res3 = SWIG_NEWOBJ;
30255 }
30256 }
30257 {
30258 PyThreadState* __tstate = wxPyBeginAllowThreads();
30259 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30260
30261 wxPyEndAllowThreads(__tstate);
30262 if (PyErr_Occurred()) SWIG_fail;
30263 }
30264 Py_INCREF(Py_None); resultobj = Py_None;
30265 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30266 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30267 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30268 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30269 return resultobj;
30270 fail:
30271 return NULL;
30272 }
30273
30274
30275 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30276 PyObject *resultobj;
30277 wxWindow *arg1 = (wxWindow *) 0 ;
30278 int *arg2 = (int *) 0 ;
30279 int *arg3 = (int *) 0 ;
30280 int temp2 ;
30281 int res2 = 0 ;
30282 int temp3 ;
30283 int res3 = 0 ;
30284 PyObject * obj0 = 0 ;
30285 PyObject * obj1 = 0 ;
30286 PyObject * obj2 = 0 ;
30287 char *kwnames[] = {
30288 (char *) "self",(char *) "x",(char *) "y", NULL
30289 };
30290
30291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30293 if (SWIG_arg_fail(1)) SWIG_fail;
30294 {
30295 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30296 temp2 = SWIG_As_int(obj1);
30297 if (SWIG_arg_fail(2)) SWIG_fail;
30298 arg2 = &temp2;
30299 res2 = SWIG_NEWOBJ;
30300 }
30301 }
30302 {
30303 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30304 temp3 = SWIG_As_int(obj2);
30305 if (SWIG_arg_fail(3)) SWIG_fail;
30306 arg3 = &temp3;
30307 res3 = SWIG_NEWOBJ;
30308 }
30309 }
30310 {
30311 PyThreadState* __tstate = wxPyBeginAllowThreads();
30312 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30313
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 Py_INCREF(Py_None); resultobj = Py_None;
30318 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30319 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30320 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30321 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30329 PyObject *resultobj;
30330 wxWindow *arg1 = (wxWindow *) 0 ;
30331 wxPoint *arg2 = 0 ;
30332 wxPoint result;
30333 wxPoint temp2 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 char *kwnames[] = {
30337 (char *) "self",(char *) "pt", NULL
30338 };
30339
30340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30342 if (SWIG_arg_fail(1)) SWIG_fail;
30343 {
30344 arg2 = &temp2;
30345 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30346 }
30347 {
30348 PyThreadState* __tstate = wxPyBeginAllowThreads();
30349 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30350
30351 wxPyEndAllowThreads(__tstate);
30352 if (PyErr_Occurred()) SWIG_fail;
30353 }
30354 {
30355 wxPoint * resultptr;
30356 resultptr = new wxPoint((wxPoint &)(result));
30357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30358 }
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj;
30367 wxWindow *arg1 = (wxWindow *) 0 ;
30368 wxPoint *arg2 = 0 ;
30369 wxPoint result;
30370 wxPoint temp2 ;
30371 PyObject * obj0 = 0 ;
30372 PyObject * obj1 = 0 ;
30373 char *kwnames[] = {
30374 (char *) "self",(char *) "pt", NULL
30375 };
30376
30377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30379 if (SWIG_arg_fail(1)) SWIG_fail;
30380 {
30381 arg2 = &temp2;
30382 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30383 }
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30387
30388 wxPyEndAllowThreads(__tstate);
30389 if (PyErr_Occurred()) SWIG_fail;
30390 }
30391 {
30392 wxPoint * resultptr;
30393 resultptr = new wxPoint((wxPoint &)(result));
30394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30395 }
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj;
30404 wxWindow *arg1 = (wxWindow *) 0 ;
30405 int arg2 ;
30406 int arg3 ;
30407 wxHitTest result;
30408 PyObject * obj0 = 0 ;
30409 PyObject * obj1 = 0 ;
30410 PyObject * obj2 = 0 ;
30411 char *kwnames[] = {
30412 (char *) "self",(char *) "x",(char *) "y", NULL
30413 };
30414
30415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30417 if (SWIG_arg_fail(1)) SWIG_fail;
30418 {
30419 arg2 = (int)(SWIG_As_int(obj1));
30420 if (SWIG_arg_fail(2)) SWIG_fail;
30421 }
30422 {
30423 arg3 = (int)(SWIG_As_int(obj2));
30424 if (SWIG_arg_fail(3)) SWIG_fail;
30425 }
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30429
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_From_int((result));
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 wxPoint *arg2 = 0 ;
30444 wxHitTest result;
30445 wxPoint temp2 ;
30446 PyObject * obj0 = 0 ;
30447 PyObject * obj1 = 0 ;
30448 char *kwnames[] = {
30449 (char *) "self",(char *) "pt", NULL
30450 };
30451
30452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30454 if (SWIG_arg_fail(1)) SWIG_fail;
30455 {
30456 arg2 = &temp2;
30457 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30458 }
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30462
30463 wxPyEndAllowThreads(__tstate);
30464 if (PyErr_Occurred()) SWIG_fail;
30465 }
30466 resultobj = SWIG_From_int((result));
30467 return resultobj;
30468 fail:
30469 return NULL;
30470 }
30471
30472
30473 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30474 PyObject *resultobj;
30475 wxWindow *arg1 = (wxWindow *) 0 ;
30476 long arg2 ;
30477 wxBorder result;
30478 PyObject * obj0 = 0 ;
30479 PyObject * obj1 = 0 ;
30480
30481 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30483 if (SWIG_arg_fail(1)) SWIG_fail;
30484 {
30485 arg2 = (long)(SWIG_As_long(obj1));
30486 if (SWIG_arg_fail(2)) SWIG_fail;
30487 }
30488 {
30489 PyThreadState* __tstate = wxPyBeginAllowThreads();
30490 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30491
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_From_int((result));
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30503 PyObject *resultobj;
30504 wxWindow *arg1 = (wxWindow *) 0 ;
30505 wxBorder result;
30506 PyObject * obj0 = 0 ;
30507
30508 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30510 if (SWIG_arg_fail(1)) SWIG_fail;
30511 {
30512 PyThreadState* __tstate = wxPyBeginAllowThreads();
30513 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30514
30515 wxPyEndAllowThreads(__tstate);
30516 if (PyErr_Occurred()) SWIG_fail;
30517 }
30518 resultobj = SWIG_From_int((result));
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30526 int argc;
30527 PyObject *argv[3];
30528 int ii;
30529
30530 argc = PyObject_Length(args);
30531 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30532 argv[ii] = PyTuple_GetItem(args,ii);
30533 }
30534 if (argc == 1) {
30535 int _v;
30536 {
30537 void *ptr;
30538 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30539 _v = 0;
30540 PyErr_Clear();
30541 } else {
30542 _v = 1;
30543 }
30544 }
30545 if (_v) {
30546 return _wrap_Window_GetBorder__SWIG_1(self,args);
30547 }
30548 }
30549 if (argc == 2) {
30550 int _v;
30551 {
30552 void *ptr;
30553 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30554 _v = 0;
30555 PyErr_Clear();
30556 } else {
30557 _v = 1;
30558 }
30559 }
30560 if (_v) {
30561 _v = SWIG_Check_long(argv[1]);
30562 if (_v) {
30563 return _wrap_Window_GetBorder__SWIG_0(self,args);
30564 }
30565 }
30566 }
30567
30568 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30569 return NULL;
30570 }
30571
30572
30573 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30574 PyObject *resultobj;
30575 wxWindow *arg1 = (wxWindow *) 0 ;
30576 long arg2 = (long) wxUPDATE_UI_NONE ;
30577 PyObject * obj0 = 0 ;
30578 PyObject * obj1 = 0 ;
30579 char *kwnames[] = {
30580 (char *) "self",(char *) "flags", NULL
30581 };
30582
30583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30585 if (SWIG_arg_fail(1)) SWIG_fail;
30586 if (obj1) {
30587 {
30588 arg2 = (long)(SWIG_As_long(obj1));
30589 if (SWIG_arg_fail(2)) SWIG_fail;
30590 }
30591 }
30592 {
30593 PyThreadState* __tstate = wxPyBeginAllowThreads();
30594 (arg1)->UpdateWindowUI(arg2);
30595
30596 wxPyEndAllowThreads(__tstate);
30597 if (PyErr_Occurred()) SWIG_fail;
30598 }
30599 Py_INCREF(Py_None); resultobj = Py_None;
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj;
30608 wxWindow *arg1 = (wxWindow *) 0 ;
30609 wxMenu *arg2 = (wxMenu *) 0 ;
30610 int arg3 = (int) -1 ;
30611 int arg4 = (int) -1 ;
30612 bool result;
30613 PyObject * obj0 = 0 ;
30614 PyObject * obj1 = 0 ;
30615 PyObject * obj2 = 0 ;
30616 PyObject * obj3 = 0 ;
30617 char *kwnames[] = {
30618 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30619 };
30620
30621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30623 if (SWIG_arg_fail(1)) SWIG_fail;
30624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30625 if (SWIG_arg_fail(2)) SWIG_fail;
30626 if (obj2) {
30627 {
30628 arg3 = (int)(SWIG_As_int(obj2));
30629 if (SWIG_arg_fail(3)) SWIG_fail;
30630 }
30631 }
30632 if (obj3) {
30633 {
30634 arg4 = (int)(SWIG_As_int(obj3));
30635 if (SWIG_arg_fail(4)) SWIG_fail;
30636 }
30637 }
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30641
30642 wxPyEndAllowThreads(__tstate);
30643 if (PyErr_Occurred()) SWIG_fail;
30644 }
30645 {
30646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30647 }
30648 return resultobj;
30649 fail:
30650 return NULL;
30651 }
30652
30653
30654 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30655 PyObject *resultobj;
30656 wxWindow *arg1 = (wxWindow *) 0 ;
30657 wxMenu *arg2 = (wxMenu *) 0 ;
30658 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30659 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30660 bool result;
30661 wxPoint temp3 ;
30662 PyObject * obj0 = 0 ;
30663 PyObject * obj1 = 0 ;
30664 PyObject * obj2 = 0 ;
30665 char *kwnames[] = {
30666 (char *) "self",(char *) "menu",(char *) "pos", NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30671 if (SWIG_arg_fail(1)) SWIG_fail;
30672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30673 if (SWIG_arg_fail(2)) SWIG_fail;
30674 if (obj2) {
30675 {
30676 arg3 = &temp3;
30677 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30678 }
30679 }
30680 {
30681 PyThreadState* __tstate = wxPyBeginAllowThreads();
30682 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30683
30684 wxPyEndAllowThreads(__tstate);
30685 if (PyErr_Occurred()) SWIG_fail;
30686 }
30687 {
30688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30689 }
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30697 PyObject *resultobj;
30698 wxWindow *arg1 = (wxWindow *) 0 ;
30699 long result;
30700 PyObject * obj0 = 0 ;
30701 char *kwnames[] = {
30702 (char *) "self", NULL
30703 };
30704
30705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30707 if (SWIG_arg_fail(1)) SWIG_fail;
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (long)wxWindow_GetHandle(arg1);
30711
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 {
30716 resultobj = SWIG_From_long((long)(result));
30717 }
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30725 PyObject *resultobj;
30726 wxWindow *arg1 = (wxWindow *) 0 ;
30727 long arg2 ;
30728 PyObject * obj0 = 0 ;
30729 PyObject * obj1 = 0 ;
30730 char *kwnames[] = {
30731 (char *) "self",(char *) "handle", NULL
30732 };
30733
30734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30736 if (SWIG_arg_fail(1)) SWIG_fail;
30737 {
30738 arg2 = (long)(SWIG_As_long(obj1));
30739 if (SWIG_arg_fail(2)) SWIG_fail;
30740 }
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 wxWindow_AssociateHandle(arg1,arg2);
30744
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 Py_INCREF(Py_None); resultobj = Py_None;
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30756 PyObject *resultobj;
30757 wxWindow *arg1 = (wxWindow *) 0 ;
30758 PyObject * obj0 = 0 ;
30759 char *kwnames[] = {
30760 (char *) "self", NULL
30761 };
30762
30763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30765 if (SWIG_arg_fail(1)) SWIG_fail;
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 (arg1)->DissociateHandle();
30769
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 Py_INCREF(Py_None); resultobj = Py_None;
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxPaintEvent *arg2 = 0 ;
30784 PyObject * obj0 = 0 ;
30785 PyObject * obj1 = 0 ;
30786 char *kwnames[] = {
30787 (char *) "self",(char *) "event", NULL
30788 };
30789
30790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30792 if (SWIG_arg_fail(1)) SWIG_fail;
30793 {
30794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30795 if (SWIG_arg_fail(2)) SWIG_fail;
30796 if (arg2 == NULL) {
30797 SWIG_null_ref("wxPaintEvent");
30798 }
30799 if (SWIG_arg_fail(2)) SWIG_fail;
30800 }
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 (arg1)->OnPaint(*arg2);
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 Py_INCREF(Py_None); resultobj = Py_None;
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 int arg2 ;
30819 bool result;
30820 PyObject * obj0 = 0 ;
30821 PyObject * obj1 = 0 ;
30822 char *kwnames[] = {
30823 (char *) "self",(char *) "orient", NULL
30824 };
30825
30826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30828 if (SWIG_arg_fail(1)) SWIG_fail;
30829 {
30830 arg2 = (int)(SWIG_As_int(obj1));
30831 if (SWIG_arg_fail(2)) SWIG_fail;
30832 }
30833 {
30834 PyThreadState* __tstate = wxPyBeginAllowThreads();
30835 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30836
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 {
30841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30842 }
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30850 PyObject *resultobj;
30851 wxWindow *arg1 = (wxWindow *) 0 ;
30852 int arg2 ;
30853 int arg3 ;
30854 int arg4 ;
30855 int arg5 ;
30856 bool arg6 = (bool) true ;
30857 PyObject * obj0 = 0 ;
30858 PyObject * obj1 = 0 ;
30859 PyObject * obj2 = 0 ;
30860 PyObject * obj3 = 0 ;
30861 PyObject * obj4 = 0 ;
30862 PyObject * obj5 = 0 ;
30863 char *kwnames[] = {
30864 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30865 };
30866
30867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30869 if (SWIG_arg_fail(1)) SWIG_fail;
30870 {
30871 arg2 = (int)(SWIG_As_int(obj1));
30872 if (SWIG_arg_fail(2)) SWIG_fail;
30873 }
30874 {
30875 arg3 = (int)(SWIG_As_int(obj2));
30876 if (SWIG_arg_fail(3)) SWIG_fail;
30877 }
30878 {
30879 arg4 = (int)(SWIG_As_int(obj3));
30880 if (SWIG_arg_fail(4)) SWIG_fail;
30881 }
30882 {
30883 arg5 = (int)(SWIG_As_int(obj4));
30884 if (SWIG_arg_fail(5)) SWIG_fail;
30885 }
30886 if (obj5) {
30887 {
30888 arg6 = (bool)(SWIG_As_bool(obj5));
30889 if (SWIG_arg_fail(6)) SWIG_fail;
30890 }
30891 }
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30895
30896 wxPyEndAllowThreads(__tstate);
30897 if (PyErr_Occurred()) SWIG_fail;
30898 }
30899 Py_INCREF(Py_None); resultobj = Py_None;
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30907 PyObject *resultobj;
30908 wxWindow *arg1 = (wxWindow *) 0 ;
30909 int arg2 ;
30910 int arg3 ;
30911 bool arg4 = (bool) true ;
30912 PyObject * obj0 = 0 ;
30913 PyObject * obj1 = 0 ;
30914 PyObject * obj2 = 0 ;
30915 PyObject * obj3 = 0 ;
30916 char *kwnames[] = {
30917 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30918 };
30919
30920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30922 if (SWIG_arg_fail(1)) SWIG_fail;
30923 {
30924 arg2 = (int)(SWIG_As_int(obj1));
30925 if (SWIG_arg_fail(2)) SWIG_fail;
30926 }
30927 {
30928 arg3 = (int)(SWIG_As_int(obj2));
30929 if (SWIG_arg_fail(3)) SWIG_fail;
30930 }
30931 if (obj3) {
30932 {
30933 arg4 = (bool)(SWIG_As_bool(obj3));
30934 if (SWIG_arg_fail(4)) SWIG_fail;
30935 }
30936 }
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 (arg1)->SetScrollPos(arg2,arg3,arg4);
30940
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 Py_INCREF(Py_None); resultobj = Py_None;
30945 return resultobj;
30946 fail:
30947 return NULL;
30948 }
30949
30950
30951 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30952 PyObject *resultobj;
30953 wxWindow *arg1 = (wxWindow *) 0 ;
30954 int arg2 ;
30955 int result;
30956 PyObject * obj0 = 0 ;
30957 PyObject * obj1 = 0 ;
30958 char *kwnames[] = {
30959 (char *) "self",(char *) "orientation", NULL
30960 };
30961
30962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30964 if (SWIG_arg_fail(1)) SWIG_fail;
30965 {
30966 arg2 = (int)(SWIG_As_int(obj1));
30967 if (SWIG_arg_fail(2)) SWIG_fail;
30968 }
30969 {
30970 PyThreadState* __tstate = wxPyBeginAllowThreads();
30971 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30972
30973 wxPyEndAllowThreads(__tstate);
30974 if (PyErr_Occurred()) SWIG_fail;
30975 }
30976 {
30977 resultobj = SWIG_From_int((int)(result));
30978 }
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30986 PyObject *resultobj;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 int arg2 ;
30989 int result;
30990 PyObject * obj0 = 0 ;
30991 PyObject * obj1 = 0 ;
30992 char *kwnames[] = {
30993 (char *) "self",(char *) "orientation", NULL
30994 };
30995
30996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30998 if (SWIG_arg_fail(1)) SWIG_fail;
30999 {
31000 arg2 = (int)(SWIG_As_int(obj1));
31001 if (SWIG_arg_fail(2)) SWIG_fail;
31002 }
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 {
31011 resultobj = SWIG_From_int((int)(result));
31012 }
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31020 PyObject *resultobj;
31021 wxWindow *arg1 = (wxWindow *) 0 ;
31022 int arg2 ;
31023 int result;
31024 PyObject * obj0 = 0 ;
31025 PyObject * obj1 = 0 ;
31026 char *kwnames[] = {
31027 (char *) "self",(char *) "orientation", NULL
31028 };
31029
31030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31032 if (SWIG_arg_fail(1)) SWIG_fail;
31033 {
31034 arg2 = (int)(SWIG_As_int(obj1));
31035 if (SWIG_arg_fail(2)) SWIG_fail;
31036 }
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31040
31041 wxPyEndAllowThreads(__tstate);
31042 if (PyErr_Occurred()) SWIG_fail;
31043 }
31044 {
31045 resultobj = SWIG_From_int((int)(result));
31046 }
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31054 PyObject *resultobj;
31055 wxWindow *arg1 = (wxWindow *) 0 ;
31056 int arg2 ;
31057 int arg3 ;
31058 wxRect *arg4 = (wxRect *) NULL ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 PyObject * obj2 = 0 ;
31062 PyObject * obj3 = 0 ;
31063 char *kwnames[] = {
31064 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31065 };
31066
31067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31069 if (SWIG_arg_fail(1)) SWIG_fail;
31070 {
31071 arg2 = (int)(SWIG_As_int(obj1));
31072 if (SWIG_arg_fail(2)) SWIG_fail;
31073 }
31074 {
31075 arg3 = (int)(SWIG_As_int(obj2));
31076 if (SWIG_arg_fail(3)) SWIG_fail;
31077 }
31078 if (obj3) {
31079 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31080 if (SWIG_arg_fail(4)) SWIG_fail;
31081 }
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31085
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 Py_INCREF(Py_None); resultobj = Py_None;
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31097 PyObject *resultobj;
31098 wxWindow *arg1 = (wxWindow *) 0 ;
31099 int arg2 ;
31100 bool result;
31101 PyObject * obj0 = 0 ;
31102 PyObject * obj1 = 0 ;
31103 char *kwnames[] = {
31104 (char *) "self",(char *) "lines", NULL
31105 };
31106
31107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31109 if (SWIG_arg_fail(1)) SWIG_fail;
31110 {
31111 arg2 = (int)(SWIG_As_int(obj1));
31112 if (SWIG_arg_fail(2)) SWIG_fail;
31113 }
31114 {
31115 PyThreadState* __tstate = wxPyBeginAllowThreads();
31116 result = (bool)(arg1)->ScrollLines(arg2);
31117
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 {
31122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31123 }
31124 return resultobj;
31125 fail:
31126 return NULL;
31127 }
31128
31129
31130 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31131 PyObject *resultobj;
31132 wxWindow *arg1 = (wxWindow *) 0 ;
31133 int arg2 ;
31134 bool result;
31135 PyObject * obj0 = 0 ;
31136 PyObject * obj1 = 0 ;
31137 char *kwnames[] = {
31138 (char *) "self",(char *) "pages", NULL
31139 };
31140
31141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31143 if (SWIG_arg_fail(1)) SWIG_fail;
31144 {
31145 arg2 = (int)(SWIG_As_int(obj1));
31146 if (SWIG_arg_fail(2)) SWIG_fail;
31147 }
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 result = (bool)(arg1)->ScrollPages(arg2);
31151
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 {
31156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31157 }
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 bool result;
31168 PyObject * obj0 = 0 ;
31169 char *kwnames[] = {
31170 (char *) "self", NULL
31171 };
31172
31173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31175 if (SWIG_arg_fail(1)) SWIG_fail;
31176 {
31177 PyThreadState* __tstate = wxPyBeginAllowThreads();
31178 result = (bool)(arg1)->LineUp();
31179
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 {
31184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31185 }
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31193 PyObject *resultobj;
31194 wxWindow *arg1 = (wxWindow *) 0 ;
31195 bool result;
31196 PyObject * obj0 = 0 ;
31197 char *kwnames[] = {
31198 (char *) "self", NULL
31199 };
31200
31201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31203 if (SWIG_arg_fail(1)) SWIG_fail;
31204 {
31205 PyThreadState* __tstate = wxPyBeginAllowThreads();
31206 result = (bool)(arg1)->LineDown();
31207
31208 wxPyEndAllowThreads(__tstate);
31209 if (PyErr_Occurred()) SWIG_fail;
31210 }
31211 {
31212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31213 }
31214 return resultobj;
31215 fail:
31216 return NULL;
31217 }
31218
31219
31220 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31221 PyObject *resultobj;
31222 wxWindow *arg1 = (wxWindow *) 0 ;
31223 bool result;
31224 PyObject * obj0 = 0 ;
31225 char *kwnames[] = {
31226 (char *) "self", NULL
31227 };
31228
31229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31231 if (SWIG_arg_fail(1)) SWIG_fail;
31232 {
31233 PyThreadState* __tstate = wxPyBeginAllowThreads();
31234 result = (bool)(arg1)->PageUp();
31235
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 {
31240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31241 }
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 bool result;
31252 PyObject * obj0 = 0 ;
31253 char *kwnames[] = {
31254 (char *) "self", NULL
31255 };
31256
31257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31259 if (SWIG_arg_fail(1)) SWIG_fail;
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 result = (bool)(arg1)->PageDown();
31263
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 {
31268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31269 }
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj;
31278 wxWindow *arg1 = (wxWindow *) 0 ;
31279 wxString *arg2 = 0 ;
31280 bool temp2 = false ;
31281 PyObject * obj0 = 0 ;
31282 PyObject * obj1 = 0 ;
31283 char *kwnames[] = {
31284 (char *) "self",(char *) "text", NULL
31285 };
31286
31287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31289 if (SWIG_arg_fail(1)) SWIG_fail;
31290 {
31291 arg2 = wxString_in_helper(obj1);
31292 if (arg2 == NULL) SWIG_fail;
31293 temp2 = true;
31294 }
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 (arg1)->SetHelpText((wxString const &)*arg2);
31298
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 Py_INCREF(Py_None); resultobj = Py_None;
31303 {
31304 if (temp2)
31305 delete arg2;
31306 }
31307 return resultobj;
31308 fail:
31309 {
31310 if (temp2)
31311 delete arg2;
31312 }
31313 return NULL;
31314 }
31315
31316
31317 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31318 PyObject *resultobj;
31319 wxWindow *arg1 = (wxWindow *) 0 ;
31320 wxString *arg2 = 0 ;
31321 bool temp2 = false ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char *kwnames[] = {
31325 (char *) "self",(char *) "text", NULL
31326 };
31327
31328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31330 if (SWIG_arg_fail(1)) SWIG_fail;
31331 {
31332 arg2 = wxString_in_helper(obj1);
31333 if (arg2 == NULL) SWIG_fail;
31334 temp2 = true;
31335 }
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31339
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 Py_INCREF(Py_None); resultobj = Py_None;
31344 {
31345 if (temp2)
31346 delete arg2;
31347 }
31348 return resultobj;
31349 fail:
31350 {
31351 if (temp2)
31352 delete arg2;
31353 }
31354 return NULL;
31355 }
31356
31357
31358 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj;
31360 wxWindow *arg1 = (wxWindow *) 0 ;
31361 wxString result;
31362 PyObject * obj0 = 0 ;
31363 char *kwnames[] = {
31364 (char *) "self", NULL
31365 };
31366
31367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31369 if (SWIG_arg_fail(1)) SWIG_fail;
31370 {
31371 PyThreadState* __tstate = wxPyBeginAllowThreads();
31372 result = ((wxWindow const *)arg1)->GetHelpText();
31373
31374 wxPyEndAllowThreads(__tstate);
31375 if (PyErr_Occurred()) SWIG_fail;
31376 }
31377 {
31378 #if wxUSE_UNICODE
31379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31380 #else
31381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31382 #endif
31383 }
31384 return resultobj;
31385 fail:
31386 return NULL;
31387 }
31388
31389
31390 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31391 PyObject *resultobj;
31392 wxWindow *arg1 = (wxWindow *) 0 ;
31393 wxString *arg2 = 0 ;
31394 bool temp2 = false ;
31395 PyObject * obj0 = 0 ;
31396 PyObject * obj1 = 0 ;
31397 char *kwnames[] = {
31398 (char *) "self",(char *) "tip", NULL
31399 };
31400
31401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31403 if (SWIG_arg_fail(1)) SWIG_fail;
31404 {
31405 arg2 = wxString_in_helper(obj1);
31406 if (arg2 == NULL) SWIG_fail;
31407 temp2 = true;
31408 }
31409 {
31410 PyThreadState* __tstate = wxPyBeginAllowThreads();
31411 (arg1)->SetToolTip((wxString const &)*arg2);
31412
31413 wxPyEndAllowThreads(__tstate);
31414 if (PyErr_Occurred()) SWIG_fail;
31415 }
31416 Py_INCREF(Py_None); resultobj = Py_None;
31417 {
31418 if (temp2)
31419 delete arg2;
31420 }
31421 return resultobj;
31422 fail:
31423 {
31424 if (temp2)
31425 delete arg2;
31426 }
31427 return NULL;
31428 }
31429
31430
31431 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 wxToolTip *arg2 = (wxToolTip *) 0 ;
31435 PyObject * obj0 = 0 ;
31436 PyObject * obj1 = 0 ;
31437 char *kwnames[] = {
31438 (char *) "self",(char *) "tip", NULL
31439 };
31440
31441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31443 if (SWIG_arg_fail(1)) SWIG_fail;
31444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31445 if (SWIG_arg_fail(2)) SWIG_fail;
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 (arg1)->SetToolTip(arg2);
31449
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 Py_INCREF(Py_None); resultobj = Py_None;
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31461 PyObject *resultobj;
31462 wxWindow *arg1 = (wxWindow *) 0 ;
31463 wxToolTip *result;
31464 PyObject * obj0 = 0 ;
31465 char *kwnames[] = {
31466 (char *) "self", NULL
31467 };
31468
31469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31471 if (SWIG_arg_fail(1)) SWIG_fail;
31472 {
31473 PyThreadState* __tstate = wxPyBeginAllowThreads();
31474 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31475
31476 wxPyEndAllowThreads(__tstate);
31477 if (PyErr_Occurred()) SWIG_fail;
31478 }
31479 {
31480 resultobj = wxPyMake_wxObject(result, 0);
31481 }
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31489 PyObject *resultobj;
31490 wxWindow *arg1 = (wxWindow *) 0 ;
31491 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31492 PyObject * obj0 = 0 ;
31493 PyObject * obj1 = 0 ;
31494 char *kwnames[] = {
31495 (char *) "self",(char *) "dropTarget", NULL
31496 };
31497
31498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31500 if (SWIG_arg_fail(1)) SWIG_fail;
31501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31502 if (SWIG_arg_fail(2)) SWIG_fail;
31503 {
31504 PyThreadState* __tstate = wxPyBeginAllowThreads();
31505 (arg1)->SetDropTarget(arg2);
31506
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 Py_INCREF(Py_None); resultobj = Py_None;
31511 return resultobj;
31512 fail:
31513 return NULL;
31514 }
31515
31516
31517 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31518 PyObject *resultobj;
31519 wxWindow *arg1 = (wxWindow *) 0 ;
31520 wxPyDropTarget *result;
31521 PyObject * obj0 = 0 ;
31522 char *kwnames[] = {
31523 (char *) "self", NULL
31524 };
31525
31526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31528 if (SWIG_arg_fail(1)) SWIG_fail;
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31532
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31537 return resultobj;
31538 fail:
31539 return NULL;
31540 }
31541
31542
31543 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj;
31545 wxWindow *arg1 = (wxWindow *) 0 ;
31546 bool arg2 ;
31547 PyObject * obj0 = 0 ;
31548 PyObject * obj1 = 0 ;
31549 char *kwnames[] = {
31550 (char *) "self",(char *) "accept", NULL
31551 };
31552
31553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31555 if (SWIG_arg_fail(1)) SWIG_fail;
31556 {
31557 arg2 = (bool)(SWIG_As_bool(obj1));
31558 if (SWIG_arg_fail(2)) SWIG_fail;
31559 }
31560 {
31561 PyThreadState* __tstate = wxPyBeginAllowThreads();
31562 (arg1)->DragAcceptFiles(arg2);
31563
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 Py_INCREF(Py_None); resultobj = Py_None;
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31575 PyObject *resultobj;
31576 wxWindow *arg1 = (wxWindow *) 0 ;
31577 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31578 PyObject * obj0 = 0 ;
31579 PyObject * obj1 = 0 ;
31580 char *kwnames[] = {
31581 (char *) "self",(char *) "constraints", NULL
31582 };
31583
31584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31586 if (SWIG_arg_fail(1)) SWIG_fail;
31587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31588 if (SWIG_arg_fail(2)) SWIG_fail;
31589 {
31590 PyThreadState* __tstate = wxPyBeginAllowThreads();
31591 (arg1)->SetConstraints(arg2);
31592
31593 wxPyEndAllowThreads(__tstate);
31594 if (PyErr_Occurred()) SWIG_fail;
31595 }
31596 Py_INCREF(Py_None); resultobj = Py_None;
31597 return resultobj;
31598 fail:
31599 return NULL;
31600 }
31601
31602
31603 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31604 PyObject *resultobj;
31605 wxWindow *arg1 = (wxWindow *) 0 ;
31606 wxLayoutConstraints *result;
31607 PyObject * obj0 = 0 ;
31608 char *kwnames[] = {
31609 (char *) "self", NULL
31610 };
31611
31612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31614 if (SWIG_arg_fail(1)) SWIG_fail;
31615 {
31616 PyThreadState* __tstate = wxPyBeginAllowThreads();
31617 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31618
31619 wxPyEndAllowThreads(__tstate);
31620 if (PyErr_Occurred()) SWIG_fail;
31621 }
31622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31630 PyObject *resultobj;
31631 wxWindow *arg1 = (wxWindow *) 0 ;
31632 bool arg2 ;
31633 PyObject * obj0 = 0 ;
31634 PyObject * obj1 = 0 ;
31635 char *kwnames[] = {
31636 (char *) "self",(char *) "autoLayout", NULL
31637 };
31638
31639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31641 if (SWIG_arg_fail(1)) SWIG_fail;
31642 {
31643 arg2 = (bool)(SWIG_As_bool(obj1));
31644 if (SWIG_arg_fail(2)) SWIG_fail;
31645 }
31646 {
31647 PyThreadState* __tstate = wxPyBeginAllowThreads();
31648 (arg1)->SetAutoLayout(arg2);
31649
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 Py_INCREF(Py_None); resultobj = Py_None;
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31661 PyObject *resultobj;
31662 wxWindow *arg1 = (wxWindow *) 0 ;
31663 bool result;
31664 PyObject * obj0 = 0 ;
31665 char *kwnames[] = {
31666 (char *) "self", NULL
31667 };
31668
31669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31671 if (SWIG_arg_fail(1)) SWIG_fail;
31672 {
31673 PyThreadState* __tstate = wxPyBeginAllowThreads();
31674 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31675
31676 wxPyEndAllowThreads(__tstate);
31677 if (PyErr_Occurred()) SWIG_fail;
31678 }
31679 {
31680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31681 }
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31689 PyObject *resultobj;
31690 wxWindow *arg1 = (wxWindow *) 0 ;
31691 bool result;
31692 PyObject * obj0 = 0 ;
31693 char *kwnames[] = {
31694 (char *) "self", NULL
31695 };
31696
31697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31699 if (SWIG_arg_fail(1)) SWIG_fail;
31700 {
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 result = (bool)(arg1)->Layout();
31703
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 {
31708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxSizer *arg2 = (wxSizer *) 0 ;
31720 bool arg3 = (bool) true ;
31721 PyObject * obj0 = 0 ;
31722 PyObject * obj1 = 0 ;
31723 PyObject * obj2 = 0 ;
31724 char *kwnames[] = {
31725 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31726 };
31727
31728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31730 if (SWIG_arg_fail(1)) SWIG_fail;
31731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31732 if (SWIG_arg_fail(2)) SWIG_fail;
31733 if (obj2) {
31734 {
31735 arg3 = (bool)(SWIG_As_bool(obj2));
31736 if (SWIG_arg_fail(3)) SWIG_fail;
31737 }
31738 }
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 (arg1)->SetSizer(arg2,arg3);
31742
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 Py_INCREF(Py_None); resultobj = Py_None;
31747 return resultobj;
31748 fail:
31749 return NULL;
31750 }
31751
31752
31753 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31754 PyObject *resultobj;
31755 wxWindow *arg1 = (wxWindow *) 0 ;
31756 wxSizer *arg2 = (wxSizer *) 0 ;
31757 bool arg3 = (bool) true ;
31758 PyObject * obj0 = 0 ;
31759 PyObject * obj1 = 0 ;
31760 PyObject * obj2 = 0 ;
31761 char *kwnames[] = {
31762 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31763 };
31764
31765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31767 if (SWIG_arg_fail(1)) SWIG_fail;
31768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31769 if (SWIG_arg_fail(2)) SWIG_fail;
31770 if (obj2) {
31771 {
31772 arg3 = (bool)(SWIG_As_bool(obj2));
31773 if (SWIG_arg_fail(3)) SWIG_fail;
31774 }
31775 }
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 (arg1)->SetSizerAndFit(arg2,arg3);
31779
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 Py_INCREF(Py_None); resultobj = Py_None;
31784 return resultobj;
31785 fail:
31786 return NULL;
31787 }
31788
31789
31790 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31791 PyObject *resultobj;
31792 wxWindow *arg1 = (wxWindow *) 0 ;
31793 wxSizer *result;
31794 PyObject * obj0 = 0 ;
31795 char *kwnames[] = {
31796 (char *) "self", NULL
31797 };
31798
31799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31801 if (SWIG_arg_fail(1)) SWIG_fail;
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31805
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 {
31810 resultobj = wxPyMake_wxSizer(result, 0);
31811 }
31812 return resultobj;
31813 fail:
31814 return NULL;
31815 }
31816
31817
31818 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31819 PyObject *resultobj;
31820 wxWindow *arg1 = (wxWindow *) 0 ;
31821 wxSizer *arg2 = (wxSizer *) 0 ;
31822 PyObject * obj0 = 0 ;
31823 PyObject * obj1 = 0 ;
31824 char *kwnames[] = {
31825 (char *) "self",(char *) "sizer", NULL
31826 };
31827
31828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31830 if (SWIG_arg_fail(1)) SWIG_fail;
31831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31832 if (SWIG_arg_fail(2)) SWIG_fail;
31833 {
31834 PyThreadState* __tstate = wxPyBeginAllowThreads();
31835 (arg1)->SetContainingSizer(arg2);
31836
31837 wxPyEndAllowThreads(__tstate);
31838 if (PyErr_Occurred()) SWIG_fail;
31839 }
31840 Py_INCREF(Py_None); resultobj = Py_None;
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31848 PyObject *resultobj;
31849 wxWindow *arg1 = (wxWindow *) 0 ;
31850 wxSizer *result;
31851 PyObject * obj0 = 0 ;
31852 char *kwnames[] = {
31853 (char *) "self", NULL
31854 };
31855
31856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31858 if (SWIG_arg_fail(1)) SWIG_fail;
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31862
31863 wxPyEndAllowThreads(__tstate);
31864 if (PyErr_Occurred()) SWIG_fail;
31865 }
31866 {
31867 resultobj = wxPyMake_wxSizer(result, 0);
31868 }
31869 return resultobj;
31870 fail:
31871 return NULL;
31872 }
31873
31874
31875 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31876 PyObject *resultobj;
31877 wxWindow *arg1 = (wxWindow *) 0 ;
31878 PyObject * obj0 = 0 ;
31879 char *kwnames[] = {
31880 (char *) "self", NULL
31881 };
31882
31883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31885 if (SWIG_arg_fail(1)) SWIG_fail;
31886 {
31887 PyThreadState* __tstate = wxPyBeginAllowThreads();
31888 (arg1)->InheritAttributes();
31889
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 Py_INCREF(Py_None); resultobj = Py_None;
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31901 PyObject *resultobj;
31902 wxWindow *arg1 = (wxWindow *) 0 ;
31903 bool result;
31904 PyObject * obj0 = 0 ;
31905 char *kwnames[] = {
31906 (char *) "self", NULL
31907 };
31908
31909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31911 if (SWIG_arg_fail(1)) SWIG_fail;
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31915
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 {
31920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31921 }
31922 return resultobj;
31923 fail:
31924 return NULL;
31925 }
31926
31927
31928 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31929 PyObject *obj;
31930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31931 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31932 Py_INCREF(obj);
31933 return Py_BuildValue((char *)"");
31934 }
31935 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31936 PyObject *resultobj;
31937 long arg1 ;
31938 wxWindow *arg2 = (wxWindow *) NULL ;
31939 wxWindow *result;
31940 PyObject * obj0 = 0 ;
31941 PyObject * obj1 = 0 ;
31942 char *kwnames[] = {
31943 (char *) "id",(char *) "parent", NULL
31944 };
31945
31946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31947 {
31948 arg1 = (long)(SWIG_As_long(obj0));
31949 if (SWIG_arg_fail(1)) SWIG_fail;
31950 }
31951 if (obj1) {
31952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31953 if (SWIG_arg_fail(2)) SWIG_fail;
31954 }
31955 {
31956 if (!wxPyCheckForApp()) SWIG_fail;
31957 PyThreadState* __tstate = wxPyBeginAllowThreads();
31958 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31959
31960 wxPyEndAllowThreads(__tstate);
31961 if (PyErr_Occurred()) SWIG_fail;
31962 }
31963 {
31964 resultobj = wxPyMake_wxObject(result, 0);
31965 }
31966 return resultobj;
31967 fail:
31968 return NULL;
31969 }
31970
31971
31972 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31973 PyObject *resultobj;
31974 wxString *arg1 = 0 ;
31975 wxWindow *arg2 = (wxWindow *) NULL ;
31976 wxWindow *result;
31977 bool temp1 = false ;
31978 PyObject * obj0 = 0 ;
31979 PyObject * obj1 = 0 ;
31980 char *kwnames[] = {
31981 (char *) "name",(char *) "parent", NULL
31982 };
31983
31984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31985 {
31986 arg1 = wxString_in_helper(obj0);
31987 if (arg1 == NULL) SWIG_fail;
31988 temp1 = true;
31989 }
31990 if (obj1) {
31991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31992 if (SWIG_arg_fail(2)) SWIG_fail;
31993 }
31994 {
31995 if (!wxPyCheckForApp()) SWIG_fail;
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31998
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 {
32003 resultobj = wxPyMake_wxObject(result, 0);
32004 }
32005 {
32006 if (temp1)
32007 delete arg1;
32008 }
32009 return resultobj;
32010 fail:
32011 {
32012 if (temp1)
32013 delete arg1;
32014 }
32015 return NULL;
32016 }
32017
32018
32019 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32020 PyObject *resultobj;
32021 wxString *arg1 = 0 ;
32022 wxWindow *arg2 = (wxWindow *) NULL ;
32023 wxWindow *result;
32024 bool temp1 = false ;
32025 PyObject * obj0 = 0 ;
32026 PyObject * obj1 = 0 ;
32027 char *kwnames[] = {
32028 (char *) "label",(char *) "parent", NULL
32029 };
32030
32031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32032 {
32033 arg1 = wxString_in_helper(obj0);
32034 if (arg1 == NULL) SWIG_fail;
32035 temp1 = true;
32036 }
32037 if (obj1) {
32038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32039 if (SWIG_arg_fail(2)) SWIG_fail;
32040 }
32041 {
32042 if (!wxPyCheckForApp()) SWIG_fail;
32043 PyThreadState* __tstate = wxPyBeginAllowThreads();
32044 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32045
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 {
32050 resultobj = wxPyMake_wxObject(result, 0);
32051 }
32052 {
32053 if (temp1)
32054 delete arg1;
32055 }
32056 return resultobj;
32057 fail:
32058 {
32059 if (temp1)
32060 delete arg1;
32061 }
32062 return NULL;
32063 }
32064
32065
32066 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32067 PyObject *resultobj;
32068 wxWindow *arg1 = (wxWindow *) 0 ;
32069 unsigned long arg2 ;
32070 wxWindow *result;
32071 PyObject * obj0 = 0 ;
32072 PyObject * obj1 = 0 ;
32073 char *kwnames[] = {
32074 (char *) "parent",(char *) "_hWnd", NULL
32075 };
32076
32077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32079 if (SWIG_arg_fail(1)) SWIG_fail;
32080 {
32081 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32082 if (SWIG_arg_fail(2)) SWIG_fail;
32083 }
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32087
32088 wxPyEndAllowThreads(__tstate);
32089 if (PyErr_Occurred()) SWIG_fail;
32090 }
32091 {
32092 resultobj = wxPyMake_wxObject(result, 0);
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj;
32102 wxValidator *result;
32103 char *kwnames[] = {
32104 NULL
32105 };
32106
32107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (wxValidator *)new wxValidator();
32111
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32123 PyObject *resultobj;
32124 wxValidator *arg1 = (wxValidator *) 0 ;
32125 wxValidator *result;
32126 PyObject * obj0 = 0 ;
32127 char *kwnames[] = {
32128 (char *) "self", NULL
32129 };
32130
32131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32133 if (SWIG_arg_fail(1)) SWIG_fail;
32134 {
32135 PyThreadState* __tstate = wxPyBeginAllowThreads();
32136 result = (wxValidator *)(arg1)->Clone();
32137
32138 wxPyEndAllowThreads(__tstate);
32139 if (PyErr_Occurred()) SWIG_fail;
32140 }
32141 {
32142 resultobj = wxPyMake_wxObject(result, 0);
32143 }
32144 return resultobj;
32145 fail:
32146 return NULL;
32147 }
32148
32149
32150 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32151 PyObject *resultobj;
32152 wxValidator *arg1 = (wxValidator *) 0 ;
32153 wxWindow *arg2 = (wxWindow *) 0 ;
32154 bool result;
32155 PyObject * obj0 = 0 ;
32156 PyObject * obj1 = 0 ;
32157 char *kwnames[] = {
32158 (char *) "self",(char *) "parent", NULL
32159 };
32160
32161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32163 if (SWIG_arg_fail(1)) SWIG_fail;
32164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32165 if (SWIG_arg_fail(2)) SWIG_fail;
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (bool)(arg1)->Validate(arg2);
32169
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 {
32174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32175 }
32176 return resultobj;
32177 fail:
32178 return NULL;
32179 }
32180
32181
32182 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32183 PyObject *resultobj;
32184 wxValidator *arg1 = (wxValidator *) 0 ;
32185 bool result;
32186 PyObject * obj0 = 0 ;
32187 char *kwnames[] = {
32188 (char *) "self", NULL
32189 };
32190
32191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32193 if (SWIG_arg_fail(1)) SWIG_fail;
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = (bool)(arg1)->TransferToWindow();
32197
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 {
32202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32203 }
32204 return resultobj;
32205 fail:
32206 return NULL;
32207 }
32208
32209
32210 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj;
32212 wxValidator *arg1 = (wxValidator *) 0 ;
32213 bool result;
32214 PyObject * obj0 = 0 ;
32215 char *kwnames[] = {
32216 (char *) "self", NULL
32217 };
32218
32219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32221 if (SWIG_arg_fail(1)) SWIG_fail;
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = (bool)(arg1)->TransferFromWindow();
32225
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 {
32230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32231 }
32232 return resultobj;
32233 fail:
32234 return NULL;
32235 }
32236
32237
32238 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32239 PyObject *resultobj;
32240 wxValidator *arg1 = (wxValidator *) 0 ;
32241 wxWindow *result;
32242 PyObject * obj0 = 0 ;
32243 char *kwnames[] = {
32244 (char *) "self", NULL
32245 };
32246
32247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32249 if (SWIG_arg_fail(1)) SWIG_fail;
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = (wxWindow *)(arg1)->GetWindow();
32253
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 {
32258 resultobj = wxPyMake_wxObject(result, 0);
32259 }
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32267 PyObject *resultobj;
32268 wxValidator *arg1 = (wxValidator *) 0 ;
32269 wxWindow *arg2 = (wxWindow *) 0 ;
32270 PyObject * obj0 = 0 ;
32271 PyObject * obj1 = 0 ;
32272 char *kwnames[] = {
32273 (char *) "self",(char *) "window", NULL
32274 };
32275
32276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32278 if (SWIG_arg_fail(1)) SWIG_fail;
32279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32280 if (SWIG_arg_fail(2)) SWIG_fail;
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 (arg1)->SetWindow(arg2);
32284
32285 wxPyEndAllowThreads(__tstate);
32286 if (PyErr_Occurred()) SWIG_fail;
32287 }
32288 Py_INCREF(Py_None); resultobj = Py_None;
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32296 PyObject *resultobj;
32297 bool result;
32298 char *kwnames[] = {
32299 NULL
32300 };
32301
32302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (bool)wxValidator::IsSilent();
32306
32307 wxPyEndAllowThreads(__tstate);
32308 if (PyErr_Occurred()) SWIG_fail;
32309 }
32310 {
32311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32312 }
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj;
32321 int arg1 = (int) true ;
32322 PyObject * obj0 = 0 ;
32323 char *kwnames[] = {
32324 (char *) "doIt", NULL
32325 };
32326
32327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32328 if (obj0) {
32329 {
32330 arg1 = (int)(SWIG_As_int(obj0));
32331 if (SWIG_arg_fail(1)) SWIG_fail;
32332 }
32333 }
32334 {
32335 PyThreadState* __tstate = wxPyBeginAllowThreads();
32336 wxValidator::SetBellOnError(arg1);
32337
32338 wxPyEndAllowThreads(__tstate);
32339 if (PyErr_Occurred()) SWIG_fail;
32340 }
32341 Py_INCREF(Py_None); resultobj = Py_None;
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32349 PyObject *obj;
32350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32351 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32352 Py_INCREF(obj);
32353 return Py_BuildValue((char *)"");
32354 }
32355 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj;
32357 wxPyValidator *result;
32358 char *kwnames[] = {
32359 NULL
32360 };
32361
32362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 result = (wxPyValidator *)new wxPyValidator();
32366
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32378 PyObject *resultobj;
32379 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32380 PyObject *arg2 = (PyObject *) 0 ;
32381 PyObject *arg3 = (PyObject *) 0 ;
32382 int arg4 = (int) true ;
32383 PyObject * obj0 = 0 ;
32384 PyObject * obj1 = 0 ;
32385 PyObject * obj2 = 0 ;
32386 PyObject * obj3 = 0 ;
32387 char *kwnames[] = {
32388 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32389 };
32390
32391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32393 if (SWIG_arg_fail(1)) SWIG_fail;
32394 arg2 = obj1;
32395 arg3 = obj2;
32396 if (obj3) {
32397 {
32398 arg4 = (int)(SWIG_As_int(obj3));
32399 if (SWIG_arg_fail(4)) SWIG_fail;
32400 }
32401 }
32402 {
32403 PyThreadState* __tstate = wxPyBeginAllowThreads();
32404 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32405
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 Py_INCREF(Py_None); resultobj = Py_None;
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32417 PyObject *obj;
32418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32419 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32420 Py_INCREF(obj);
32421 return Py_BuildValue((char *)"");
32422 }
32423 static int _wrap_DefaultValidator_set(PyObject *) {
32424 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32425 return 1;
32426 }
32427
32428
32429 static PyObject *_wrap_DefaultValidator_get(void) {
32430 PyObject *pyobj;
32431
32432 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32433 return pyobj;
32434 }
32435
32436
32437 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32438 PyObject *resultobj;
32439 wxString const &arg1_defvalue = wxPyEmptyString ;
32440 wxString *arg1 = (wxString *) &arg1_defvalue ;
32441 long arg2 = (long) 0 ;
32442 wxMenu *result;
32443 bool temp1 = false ;
32444 PyObject * obj0 = 0 ;
32445 PyObject * obj1 = 0 ;
32446 char *kwnames[] = {
32447 (char *) "title",(char *) "style", NULL
32448 };
32449
32450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32451 if (obj0) {
32452 {
32453 arg1 = wxString_in_helper(obj0);
32454 if (arg1 == NULL) SWIG_fail;
32455 temp1 = true;
32456 }
32457 }
32458 if (obj1) {
32459 {
32460 arg2 = (long)(SWIG_As_long(obj1));
32461 if (SWIG_arg_fail(2)) SWIG_fail;
32462 }
32463 }
32464 {
32465 if (!wxPyCheckForApp()) SWIG_fail;
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32468
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32473 {
32474 if (temp1)
32475 delete arg1;
32476 }
32477 return resultobj;
32478 fail:
32479 {
32480 if (temp1)
32481 delete arg1;
32482 }
32483 return NULL;
32484 }
32485
32486
32487 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32488 PyObject *resultobj;
32489 wxMenu *arg1 = (wxMenu *) 0 ;
32490 int arg2 ;
32491 wxString *arg3 = 0 ;
32492 wxString const &arg4_defvalue = wxPyEmptyString ;
32493 wxString *arg4 = (wxString *) &arg4_defvalue ;
32494 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32495 wxMenuItem *result;
32496 bool temp3 = false ;
32497 bool temp4 = false ;
32498 PyObject * obj0 = 0 ;
32499 PyObject * obj1 = 0 ;
32500 PyObject * obj2 = 0 ;
32501 PyObject * obj3 = 0 ;
32502 PyObject * obj4 = 0 ;
32503 char *kwnames[] = {
32504 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32505 };
32506
32507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32509 if (SWIG_arg_fail(1)) SWIG_fail;
32510 {
32511 arg2 = (int)(SWIG_As_int(obj1));
32512 if (SWIG_arg_fail(2)) SWIG_fail;
32513 }
32514 {
32515 arg3 = wxString_in_helper(obj2);
32516 if (arg3 == NULL) SWIG_fail;
32517 temp3 = true;
32518 }
32519 if (obj3) {
32520 {
32521 arg4 = wxString_in_helper(obj3);
32522 if (arg4 == NULL) SWIG_fail;
32523 temp4 = true;
32524 }
32525 }
32526 if (obj4) {
32527 {
32528 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32529 if (SWIG_arg_fail(5)) SWIG_fail;
32530 }
32531 }
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32535
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 {
32540 resultobj = wxPyMake_wxObject(result, 0);
32541 }
32542 {
32543 if (temp3)
32544 delete arg3;
32545 }
32546 {
32547 if (temp4)
32548 delete arg4;
32549 }
32550 return resultobj;
32551 fail:
32552 {
32553 if (temp3)
32554 delete arg3;
32555 }
32556 {
32557 if (temp4)
32558 delete arg4;
32559 }
32560 return NULL;
32561 }
32562
32563
32564 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj;
32566 wxMenu *arg1 = (wxMenu *) 0 ;
32567 wxMenuItem *result;
32568 PyObject * obj0 = 0 ;
32569 char *kwnames[] = {
32570 (char *) "self", NULL
32571 };
32572
32573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32575 if (SWIG_arg_fail(1)) SWIG_fail;
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (wxMenuItem *)(arg1)->AppendSeparator();
32579
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 {
32584 resultobj = wxPyMake_wxObject(result, 0);
32585 }
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32593 PyObject *resultobj;
32594 wxMenu *arg1 = (wxMenu *) 0 ;
32595 int arg2 ;
32596 wxString *arg3 = 0 ;
32597 wxString const &arg4_defvalue = wxPyEmptyString ;
32598 wxString *arg4 = (wxString *) &arg4_defvalue ;
32599 wxMenuItem *result;
32600 bool temp3 = false ;
32601 bool temp4 = false ;
32602 PyObject * obj0 = 0 ;
32603 PyObject * obj1 = 0 ;
32604 PyObject * obj2 = 0 ;
32605 PyObject * obj3 = 0 ;
32606 char *kwnames[] = {
32607 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32608 };
32609
32610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32612 if (SWIG_arg_fail(1)) SWIG_fail;
32613 {
32614 arg2 = (int)(SWIG_As_int(obj1));
32615 if (SWIG_arg_fail(2)) SWIG_fail;
32616 }
32617 {
32618 arg3 = wxString_in_helper(obj2);
32619 if (arg3 == NULL) SWIG_fail;
32620 temp3 = true;
32621 }
32622 if (obj3) {
32623 {
32624 arg4 = wxString_in_helper(obj3);
32625 if (arg4 == NULL) SWIG_fail;
32626 temp4 = true;
32627 }
32628 }
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32632
32633 wxPyEndAllowThreads(__tstate);
32634 if (PyErr_Occurred()) SWIG_fail;
32635 }
32636 {
32637 resultobj = wxPyMake_wxObject(result, 0);
32638 }
32639 {
32640 if (temp3)
32641 delete arg3;
32642 }
32643 {
32644 if (temp4)
32645 delete arg4;
32646 }
32647 return resultobj;
32648 fail:
32649 {
32650 if (temp3)
32651 delete arg3;
32652 }
32653 {
32654 if (temp4)
32655 delete arg4;
32656 }
32657 return NULL;
32658 }
32659
32660
32661 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj;
32663 wxMenu *arg1 = (wxMenu *) 0 ;
32664 int arg2 ;
32665 wxString *arg3 = 0 ;
32666 wxString const &arg4_defvalue = wxPyEmptyString ;
32667 wxString *arg4 = (wxString *) &arg4_defvalue ;
32668 wxMenuItem *result;
32669 bool temp3 = false ;
32670 bool temp4 = false ;
32671 PyObject * obj0 = 0 ;
32672 PyObject * obj1 = 0 ;
32673 PyObject * obj2 = 0 ;
32674 PyObject * obj3 = 0 ;
32675 char *kwnames[] = {
32676 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32677 };
32678
32679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32681 if (SWIG_arg_fail(1)) SWIG_fail;
32682 {
32683 arg2 = (int)(SWIG_As_int(obj1));
32684 if (SWIG_arg_fail(2)) SWIG_fail;
32685 }
32686 {
32687 arg3 = wxString_in_helper(obj2);
32688 if (arg3 == NULL) SWIG_fail;
32689 temp3 = true;
32690 }
32691 if (obj3) {
32692 {
32693 arg4 = wxString_in_helper(obj3);
32694 if (arg4 == NULL) SWIG_fail;
32695 temp4 = true;
32696 }
32697 }
32698 {
32699 PyThreadState* __tstate = wxPyBeginAllowThreads();
32700 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32701
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 {
32706 resultobj = wxPyMake_wxObject(result, 0);
32707 }
32708 {
32709 if (temp3)
32710 delete arg3;
32711 }
32712 {
32713 if (temp4)
32714 delete arg4;
32715 }
32716 return resultobj;
32717 fail:
32718 {
32719 if (temp3)
32720 delete arg3;
32721 }
32722 {
32723 if (temp4)
32724 delete arg4;
32725 }
32726 return NULL;
32727 }
32728
32729
32730 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32731 PyObject *resultobj;
32732 wxMenu *arg1 = (wxMenu *) 0 ;
32733 int arg2 ;
32734 wxString *arg3 = 0 ;
32735 wxMenu *arg4 = (wxMenu *) 0 ;
32736 wxString const &arg5_defvalue = wxPyEmptyString ;
32737 wxString *arg5 = (wxString *) &arg5_defvalue ;
32738 wxMenuItem *result;
32739 bool temp3 = false ;
32740 bool temp5 = false ;
32741 PyObject * obj0 = 0 ;
32742 PyObject * obj1 = 0 ;
32743 PyObject * obj2 = 0 ;
32744 PyObject * obj3 = 0 ;
32745 PyObject * obj4 = 0 ;
32746 char *kwnames[] = {
32747 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32748 };
32749
32750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32752 if (SWIG_arg_fail(1)) SWIG_fail;
32753 {
32754 arg2 = (int)(SWIG_As_int(obj1));
32755 if (SWIG_arg_fail(2)) SWIG_fail;
32756 }
32757 {
32758 arg3 = wxString_in_helper(obj2);
32759 if (arg3 == NULL) SWIG_fail;
32760 temp3 = true;
32761 }
32762 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32763 if (SWIG_arg_fail(4)) SWIG_fail;
32764 if (obj4) {
32765 {
32766 arg5 = wxString_in_helper(obj4);
32767 if (arg5 == NULL) SWIG_fail;
32768 temp5 = true;
32769 }
32770 }
32771 {
32772 PyThreadState* __tstate = wxPyBeginAllowThreads();
32773 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32774
32775 wxPyEndAllowThreads(__tstate);
32776 if (PyErr_Occurred()) SWIG_fail;
32777 }
32778 {
32779 resultobj = wxPyMake_wxObject(result, 0);
32780 }
32781 {
32782 if (temp3)
32783 delete arg3;
32784 }
32785 {
32786 if (temp5)
32787 delete arg5;
32788 }
32789 return resultobj;
32790 fail:
32791 {
32792 if (temp3)
32793 delete arg3;
32794 }
32795 {
32796 if (temp5)
32797 delete arg5;
32798 }
32799 return NULL;
32800 }
32801
32802
32803 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32804 PyObject *resultobj;
32805 wxMenu *arg1 = (wxMenu *) 0 ;
32806 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32807 wxMenuItem *result;
32808 PyObject * obj0 = 0 ;
32809 PyObject * obj1 = 0 ;
32810 char *kwnames[] = {
32811 (char *) "self",(char *) "item", NULL
32812 };
32813
32814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32816 if (SWIG_arg_fail(1)) SWIG_fail;
32817 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32818 if (SWIG_arg_fail(2)) SWIG_fail;
32819 {
32820 PyThreadState* __tstate = wxPyBeginAllowThreads();
32821 result = (wxMenuItem *)(arg1)->Append(arg2);
32822
32823 wxPyEndAllowThreads(__tstate);
32824 if (PyErr_Occurred()) SWIG_fail;
32825 }
32826 {
32827 resultobj = wxPyMake_wxObject(result, 0);
32828 }
32829 return resultobj;
32830 fail:
32831 return NULL;
32832 }
32833
32834
32835 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32836 PyObject *resultobj;
32837 wxMenu *arg1 = (wxMenu *) 0 ;
32838 PyObject * obj0 = 0 ;
32839 char *kwnames[] = {
32840 (char *) "self", NULL
32841 };
32842
32843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32845 if (SWIG_arg_fail(1)) SWIG_fail;
32846 {
32847 PyThreadState* __tstate = wxPyBeginAllowThreads();
32848 (arg1)->Break();
32849
32850 wxPyEndAllowThreads(__tstate);
32851 if (PyErr_Occurred()) SWIG_fail;
32852 }
32853 Py_INCREF(Py_None); resultobj = Py_None;
32854 return resultobj;
32855 fail:
32856 return NULL;
32857 }
32858
32859
32860 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32861 PyObject *resultobj;
32862 wxMenu *arg1 = (wxMenu *) 0 ;
32863 size_t arg2 ;
32864 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32865 wxMenuItem *result;
32866 PyObject * obj0 = 0 ;
32867 PyObject * obj1 = 0 ;
32868 PyObject * obj2 = 0 ;
32869 char *kwnames[] = {
32870 (char *) "self",(char *) "pos",(char *) "item", NULL
32871 };
32872
32873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32875 if (SWIG_arg_fail(1)) SWIG_fail;
32876 {
32877 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32878 if (SWIG_arg_fail(2)) SWIG_fail;
32879 }
32880 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32881 if (SWIG_arg_fail(3)) SWIG_fail;
32882 {
32883 PyThreadState* __tstate = wxPyBeginAllowThreads();
32884 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32885
32886 wxPyEndAllowThreads(__tstate);
32887 if (PyErr_Occurred()) SWIG_fail;
32888 }
32889 {
32890 resultobj = wxPyMake_wxObject(result, 0);
32891 }
32892 return resultobj;
32893 fail:
32894 return NULL;
32895 }
32896
32897
32898 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32899 PyObject *resultobj;
32900 wxMenu *arg1 = (wxMenu *) 0 ;
32901 size_t arg2 ;
32902 int arg3 ;
32903 wxString *arg4 = 0 ;
32904 wxString const &arg5_defvalue = wxPyEmptyString ;
32905 wxString *arg5 = (wxString *) &arg5_defvalue ;
32906 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32907 wxMenuItem *result;
32908 bool temp4 = false ;
32909 bool temp5 = false ;
32910 PyObject * obj0 = 0 ;
32911 PyObject * obj1 = 0 ;
32912 PyObject * obj2 = 0 ;
32913 PyObject * obj3 = 0 ;
32914 PyObject * obj4 = 0 ;
32915 PyObject * obj5 = 0 ;
32916 char *kwnames[] = {
32917 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32918 };
32919
32920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32922 if (SWIG_arg_fail(1)) SWIG_fail;
32923 {
32924 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32925 if (SWIG_arg_fail(2)) SWIG_fail;
32926 }
32927 {
32928 arg3 = (int)(SWIG_As_int(obj2));
32929 if (SWIG_arg_fail(3)) SWIG_fail;
32930 }
32931 {
32932 arg4 = wxString_in_helper(obj3);
32933 if (arg4 == NULL) SWIG_fail;
32934 temp4 = true;
32935 }
32936 if (obj4) {
32937 {
32938 arg5 = wxString_in_helper(obj4);
32939 if (arg5 == NULL) SWIG_fail;
32940 temp5 = true;
32941 }
32942 }
32943 if (obj5) {
32944 {
32945 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32946 if (SWIG_arg_fail(6)) SWIG_fail;
32947 }
32948 }
32949 {
32950 PyThreadState* __tstate = wxPyBeginAllowThreads();
32951 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32952
32953 wxPyEndAllowThreads(__tstate);
32954 if (PyErr_Occurred()) SWIG_fail;
32955 }
32956 {
32957 resultobj = wxPyMake_wxObject(result, 0);
32958 }
32959 {
32960 if (temp4)
32961 delete arg4;
32962 }
32963 {
32964 if (temp5)
32965 delete arg5;
32966 }
32967 return resultobj;
32968 fail:
32969 {
32970 if (temp4)
32971 delete arg4;
32972 }
32973 {
32974 if (temp5)
32975 delete arg5;
32976 }
32977 return NULL;
32978 }
32979
32980
32981 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32982 PyObject *resultobj;
32983 wxMenu *arg1 = (wxMenu *) 0 ;
32984 size_t arg2 ;
32985 wxMenuItem *result;
32986 PyObject * obj0 = 0 ;
32987 PyObject * obj1 = 0 ;
32988 char *kwnames[] = {
32989 (char *) "self",(char *) "pos", NULL
32990 };
32991
32992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32994 if (SWIG_arg_fail(1)) SWIG_fail;
32995 {
32996 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32997 if (SWIG_arg_fail(2)) SWIG_fail;
32998 }
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33002
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 {
33007 resultobj = wxPyMake_wxObject(result, 0);
33008 }
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj;
33017 wxMenu *arg1 = (wxMenu *) 0 ;
33018 size_t arg2 ;
33019 int arg3 ;
33020 wxString *arg4 = 0 ;
33021 wxString const &arg5_defvalue = wxPyEmptyString ;
33022 wxString *arg5 = (wxString *) &arg5_defvalue ;
33023 wxMenuItem *result;
33024 bool temp4 = false ;
33025 bool temp5 = false ;
33026 PyObject * obj0 = 0 ;
33027 PyObject * obj1 = 0 ;
33028 PyObject * obj2 = 0 ;
33029 PyObject * obj3 = 0 ;
33030 PyObject * obj4 = 0 ;
33031 char *kwnames[] = {
33032 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33033 };
33034
33035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33037 if (SWIG_arg_fail(1)) SWIG_fail;
33038 {
33039 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33040 if (SWIG_arg_fail(2)) SWIG_fail;
33041 }
33042 {
33043 arg3 = (int)(SWIG_As_int(obj2));
33044 if (SWIG_arg_fail(3)) SWIG_fail;
33045 }
33046 {
33047 arg4 = wxString_in_helper(obj3);
33048 if (arg4 == NULL) SWIG_fail;
33049 temp4 = true;
33050 }
33051 if (obj4) {
33052 {
33053 arg5 = wxString_in_helper(obj4);
33054 if (arg5 == NULL) SWIG_fail;
33055 temp5 = true;
33056 }
33057 }
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33061
33062 wxPyEndAllowThreads(__tstate);
33063 if (PyErr_Occurred()) SWIG_fail;
33064 }
33065 {
33066 resultobj = wxPyMake_wxObject(result, 0);
33067 }
33068 {
33069 if (temp4)
33070 delete arg4;
33071 }
33072 {
33073 if (temp5)
33074 delete arg5;
33075 }
33076 return resultobj;
33077 fail:
33078 {
33079 if (temp4)
33080 delete arg4;
33081 }
33082 {
33083 if (temp5)
33084 delete arg5;
33085 }
33086 return NULL;
33087 }
33088
33089
33090 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj;
33092 wxMenu *arg1 = (wxMenu *) 0 ;
33093 size_t arg2 ;
33094 int arg3 ;
33095 wxString *arg4 = 0 ;
33096 wxString const &arg5_defvalue = wxPyEmptyString ;
33097 wxString *arg5 = (wxString *) &arg5_defvalue ;
33098 wxMenuItem *result;
33099 bool temp4 = false ;
33100 bool temp5 = false ;
33101 PyObject * obj0 = 0 ;
33102 PyObject * obj1 = 0 ;
33103 PyObject * obj2 = 0 ;
33104 PyObject * obj3 = 0 ;
33105 PyObject * obj4 = 0 ;
33106 char *kwnames[] = {
33107 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33108 };
33109
33110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33112 if (SWIG_arg_fail(1)) SWIG_fail;
33113 {
33114 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33115 if (SWIG_arg_fail(2)) SWIG_fail;
33116 }
33117 {
33118 arg3 = (int)(SWIG_As_int(obj2));
33119 if (SWIG_arg_fail(3)) SWIG_fail;
33120 }
33121 {
33122 arg4 = wxString_in_helper(obj3);
33123 if (arg4 == NULL) SWIG_fail;
33124 temp4 = true;
33125 }
33126 if (obj4) {
33127 {
33128 arg5 = wxString_in_helper(obj4);
33129 if (arg5 == NULL) SWIG_fail;
33130 temp5 = true;
33131 }
33132 }
33133 {
33134 PyThreadState* __tstate = wxPyBeginAllowThreads();
33135 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33136
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 {
33141 resultobj = wxPyMake_wxObject(result, 0);
33142 }
33143 {
33144 if (temp4)
33145 delete arg4;
33146 }
33147 {
33148 if (temp5)
33149 delete arg5;
33150 }
33151 return resultobj;
33152 fail:
33153 {
33154 if (temp4)
33155 delete arg4;
33156 }
33157 {
33158 if (temp5)
33159 delete arg5;
33160 }
33161 return NULL;
33162 }
33163
33164
33165 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33166 PyObject *resultobj;
33167 wxMenu *arg1 = (wxMenu *) 0 ;
33168 size_t arg2 ;
33169 int arg3 ;
33170 wxString *arg4 = 0 ;
33171 wxMenu *arg5 = (wxMenu *) 0 ;
33172 wxString const &arg6_defvalue = wxPyEmptyString ;
33173 wxString *arg6 = (wxString *) &arg6_defvalue ;
33174 wxMenuItem *result;
33175 bool temp4 = false ;
33176 bool temp6 = false ;
33177 PyObject * obj0 = 0 ;
33178 PyObject * obj1 = 0 ;
33179 PyObject * obj2 = 0 ;
33180 PyObject * obj3 = 0 ;
33181 PyObject * obj4 = 0 ;
33182 PyObject * obj5 = 0 ;
33183 char *kwnames[] = {
33184 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33185 };
33186
33187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33189 if (SWIG_arg_fail(1)) SWIG_fail;
33190 {
33191 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33192 if (SWIG_arg_fail(2)) SWIG_fail;
33193 }
33194 {
33195 arg3 = (int)(SWIG_As_int(obj2));
33196 if (SWIG_arg_fail(3)) SWIG_fail;
33197 }
33198 {
33199 arg4 = wxString_in_helper(obj3);
33200 if (arg4 == NULL) SWIG_fail;
33201 temp4 = true;
33202 }
33203 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33204 if (SWIG_arg_fail(5)) SWIG_fail;
33205 if (obj5) {
33206 {
33207 arg6 = wxString_in_helper(obj5);
33208 if (arg6 == NULL) SWIG_fail;
33209 temp6 = true;
33210 }
33211 }
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33215
33216 wxPyEndAllowThreads(__tstate);
33217 if (PyErr_Occurred()) SWIG_fail;
33218 }
33219 {
33220 resultobj = wxPyMake_wxObject(result, 0);
33221 }
33222 {
33223 if (temp4)
33224 delete arg4;
33225 }
33226 {
33227 if (temp6)
33228 delete arg6;
33229 }
33230 return resultobj;
33231 fail:
33232 {
33233 if (temp4)
33234 delete arg4;
33235 }
33236 {
33237 if (temp6)
33238 delete arg6;
33239 }
33240 return NULL;
33241 }
33242
33243
33244 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33245 PyObject *resultobj;
33246 wxMenu *arg1 = (wxMenu *) 0 ;
33247 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33248 wxMenuItem *result;
33249 PyObject * obj0 = 0 ;
33250 PyObject * obj1 = 0 ;
33251 char *kwnames[] = {
33252 (char *) "self",(char *) "item", NULL
33253 };
33254
33255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33257 if (SWIG_arg_fail(1)) SWIG_fail;
33258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33259 if (SWIG_arg_fail(2)) SWIG_fail;
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33263
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 {
33268 resultobj = wxPyMake_wxObject(result, 0);
33269 }
33270 return resultobj;
33271 fail:
33272 return NULL;
33273 }
33274
33275
33276 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33277 PyObject *resultobj;
33278 wxMenu *arg1 = (wxMenu *) 0 ;
33279 int arg2 ;
33280 wxString *arg3 = 0 ;
33281 wxString const &arg4_defvalue = wxPyEmptyString ;
33282 wxString *arg4 = (wxString *) &arg4_defvalue ;
33283 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33284 wxMenuItem *result;
33285 bool temp3 = false ;
33286 bool temp4 = false ;
33287 PyObject * obj0 = 0 ;
33288 PyObject * obj1 = 0 ;
33289 PyObject * obj2 = 0 ;
33290 PyObject * obj3 = 0 ;
33291 PyObject * obj4 = 0 ;
33292 char *kwnames[] = {
33293 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33294 };
33295
33296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33298 if (SWIG_arg_fail(1)) SWIG_fail;
33299 {
33300 arg2 = (int)(SWIG_As_int(obj1));
33301 if (SWIG_arg_fail(2)) SWIG_fail;
33302 }
33303 {
33304 arg3 = wxString_in_helper(obj2);
33305 if (arg3 == NULL) SWIG_fail;
33306 temp3 = true;
33307 }
33308 if (obj3) {
33309 {
33310 arg4 = wxString_in_helper(obj3);
33311 if (arg4 == NULL) SWIG_fail;
33312 temp4 = true;
33313 }
33314 }
33315 if (obj4) {
33316 {
33317 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33318 if (SWIG_arg_fail(5)) SWIG_fail;
33319 }
33320 }
33321 {
33322 PyThreadState* __tstate = wxPyBeginAllowThreads();
33323 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33324
33325 wxPyEndAllowThreads(__tstate);
33326 if (PyErr_Occurred()) SWIG_fail;
33327 }
33328 {
33329 resultobj = wxPyMake_wxObject(result, 0);
33330 }
33331 {
33332 if (temp3)
33333 delete arg3;
33334 }
33335 {
33336 if (temp4)
33337 delete arg4;
33338 }
33339 return resultobj;
33340 fail:
33341 {
33342 if (temp3)
33343 delete arg3;
33344 }
33345 {
33346 if (temp4)
33347 delete arg4;
33348 }
33349 return NULL;
33350 }
33351
33352
33353 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33354 PyObject *resultobj;
33355 wxMenu *arg1 = (wxMenu *) 0 ;
33356 wxMenuItem *result;
33357 PyObject * obj0 = 0 ;
33358 char *kwnames[] = {
33359 (char *) "self", NULL
33360 };
33361
33362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33364 if (SWIG_arg_fail(1)) SWIG_fail;
33365 {
33366 PyThreadState* __tstate = wxPyBeginAllowThreads();
33367 result = (wxMenuItem *)(arg1)->PrependSeparator();
33368
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 {
33373 resultobj = wxPyMake_wxObject(result, 0);
33374 }
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33382 PyObject *resultobj;
33383 wxMenu *arg1 = (wxMenu *) 0 ;
33384 int arg2 ;
33385 wxString *arg3 = 0 ;
33386 wxString const &arg4_defvalue = wxPyEmptyString ;
33387 wxString *arg4 = (wxString *) &arg4_defvalue ;
33388 wxMenuItem *result;
33389 bool temp3 = false ;
33390 bool temp4 = false ;
33391 PyObject * obj0 = 0 ;
33392 PyObject * obj1 = 0 ;
33393 PyObject * obj2 = 0 ;
33394 PyObject * obj3 = 0 ;
33395 char *kwnames[] = {
33396 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33397 };
33398
33399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33401 if (SWIG_arg_fail(1)) SWIG_fail;
33402 {
33403 arg2 = (int)(SWIG_As_int(obj1));
33404 if (SWIG_arg_fail(2)) SWIG_fail;
33405 }
33406 {
33407 arg3 = wxString_in_helper(obj2);
33408 if (arg3 == NULL) SWIG_fail;
33409 temp3 = true;
33410 }
33411 if (obj3) {
33412 {
33413 arg4 = wxString_in_helper(obj3);
33414 if (arg4 == NULL) SWIG_fail;
33415 temp4 = true;
33416 }
33417 }
33418 {
33419 PyThreadState* __tstate = wxPyBeginAllowThreads();
33420 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33421
33422 wxPyEndAllowThreads(__tstate);
33423 if (PyErr_Occurred()) SWIG_fail;
33424 }
33425 {
33426 resultobj = wxPyMake_wxObject(result, 0);
33427 }
33428 {
33429 if (temp3)
33430 delete arg3;
33431 }
33432 {
33433 if (temp4)
33434 delete arg4;
33435 }
33436 return resultobj;
33437 fail:
33438 {
33439 if (temp3)
33440 delete arg3;
33441 }
33442 {
33443 if (temp4)
33444 delete arg4;
33445 }
33446 return NULL;
33447 }
33448
33449
33450 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj;
33452 wxMenu *arg1 = (wxMenu *) 0 ;
33453 int arg2 ;
33454 wxString *arg3 = 0 ;
33455 wxString const &arg4_defvalue = wxPyEmptyString ;
33456 wxString *arg4 = (wxString *) &arg4_defvalue ;
33457 wxMenuItem *result;
33458 bool temp3 = false ;
33459 bool temp4 = false ;
33460 PyObject * obj0 = 0 ;
33461 PyObject * obj1 = 0 ;
33462 PyObject * obj2 = 0 ;
33463 PyObject * obj3 = 0 ;
33464 char *kwnames[] = {
33465 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33466 };
33467
33468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33470 if (SWIG_arg_fail(1)) SWIG_fail;
33471 {
33472 arg2 = (int)(SWIG_As_int(obj1));
33473 if (SWIG_arg_fail(2)) SWIG_fail;
33474 }
33475 {
33476 arg3 = wxString_in_helper(obj2);
33477 if (arg3 == NULL) SWIG_fail;
33478 temp3 = true;
33479 }
33480 if (obj3) {
33481 {
33482 arg4 = wxString_in_helper(obj3);
33483 if (arg4 == NULL) SWIG_fail;
33484 temp4 = true;
33485 }
33486 }
33487 {
33488 PyThreadState* __tstate = wxPyBeginAllowThreads();
33489 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33490
33491 wxPyEndAllowThreads(__tstate);
33492 if (PyErr_Occurred()) SWIG_fail;
33493 }
33494 {
33495 resultobj = wxPyMake_wxObject(result, 0);
33496 }
33497 {
33498 if (temp3)
33499 delete arg3;
33500 }
33501 {
33502 if (temp4)
33503 delete arg4;
33504 }
33505 return resultobj;
33506 fail:
33507 {
33508 if (temp3)
33509 delete arg3;
33510 }
33511 {
33512 if (temp4)
33513 delete arg4;
33514 }
33515 return NULL;
33516 }
33517
33518
33519 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33520 PyObject *resultobj;
33521 wxMenu *arg1 = (wxMenu *) 0 ;
33522 int arg2 ;
33523 wxString *arg3 = 0 ;
33524 wxMenu *arg4 = (wxMenu *) 0 ;
33525 wxString const &arg5_defvalue = wxPyEmptyString ;
33526 wxString *arg5 = (wxString *) &arg5_defvalue ;
33527 wxMenuItem *result;
33528 bool temp3 = false ;
33529 bool temp5 = false ;
33530 PyObject * obj0 = 0 ;
33531 PyObject * obj1 = 0 ;
33532 PyObject * obj2 = 0 ;
33533 PyObject * obj3 = 0 ;
33534 PyObject * obj4 = 0 ;
33535 char *kwnames[] = {
33536 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33537 };
33538
33539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33541 if (SWIG_arg_fail(1)) SWIG_fail;
33542 {
33543 arg2 = (int)(SWIG_As_int(obj1));
33544 if (SWIG_arg_fail(2)) SWIG_fail;
33545 }
33546 {
33547 arg3 = wxString_in_helper(obj2);
33548 if (arg3 == NULL) SWIG_fail;
33549 temp3 = true;
33550 }
33551 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33552 if (SWIG_arg_fail(4)) SWIG_fail;
33553 if (obj4) {
33554 {
33555 arg5 = wxString_in_helper(obj4);
33556 if (arg5 == NULL) SWIG_fail;
33557 temp5 = true;
33558 }
33559 }
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33563
33564 wxPyEndAllowThreads(__tstate);
33565 if (PyErr_Occurred()) SWIG_fail;
33566 }
33567 {
33568 resultobj = wxPyMake_wxObject(result, 0);
33569 }
33570 {
33571 if (temp3)
33572 delete arg3;
33573 }
33574 {
33575 if (temp5)
33576 delete arg5;
33577 }
33578 return resultobj;
33579 fail:
33580 {
33581 if (temp3)
33582 delete arg3;
33583 }
33584 {
33585 if (temp5)
33586 delete arg5;
33587 }
33588 return NULL;
33589 }
33590
33591
33592 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33593 PyObject *resultobj;
33594 wxMenu *arg1 = (wxMenu *) 0 ;
33595 int arg2 ;
33596 wxMenuItem *result;
33597 PyObject * obj0 = 0 ;
33598 PyObject * obj1 = 0 ;
33599 char *kwnames[] = {
33600 (char *) "self",(char *) "id", NULL
33601 };
33602
33603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33605 if (SWIG_arg_fail(1)) SWIG_fail;
33606 {
33607 arg2 = (int)(SWIG_As_int(obj1));
33608 if (SWIG_arg_fail(2)) SWIG_fail;
33609 }
33610 {
33611 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 result = (wxMenuItem *)(arg1)->Remove(arg2);
33613
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 {
33618 resultobj = wxPyMake_wxObject(result, 0);
33619 }
33620 return resultobj;
33621 fail:
33622 return NULL;
33623 }
33624
33625
33626 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33627 PyObject *resultobj;
33628 wxMenu *arg1 = (wxMenu *) 0 ;
33629 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33630 wxMenuItem *result;
33631 PyObject * obj0 = 0 ;
33632 PyObject * obj1 = 0 ;
33633 char *kwnames[] = {
33634 (char *) "self",(char *) "item", NULL
33635 };
33636
33637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33639 if (SWIG_arg_fail(1)) SWIG_fail;
33640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33641 if (SWIG_arg_fail(2)) SWIG_fail;
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxMenuItem *)(arg1)->Remove(arg2);
33645
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = wxPyMake_wxObject(result, 0);
33651 }
33652 return resultobj;
33653 fail:
33654 return NULL;
33655 }
33656
33657
33658 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33659 PyObject *resultobj;
33660 wxMenu *arg1 = (wxMenu *) 0 ;
33661 int arg2 ;
33662 bool result;
33663 PyObject * obj0 = 0 ;
33664 PyObject * obj1 = 0 ;
33665 char *kwnames[] = {
33666 (char *) "self",(char *) "id", NULL
33667 };
33668
33669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33671 if (SWIG_arg_fail(1)) SWIG_fail;
33672 {
33673 arg2 = (int)(SWIG_As_int(obj1));
33674 if (SWIG_arg_fail(2)) SWIG_fail;
33675 }
33676 {
33677 PyThreadState* __tstate = wxPyBeginAllowThreads();
33678 result = (bool)(arg1)->Delete(arg2);
33679
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 {
33684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33685 }
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33693 PyObject *resultobj;
33694 wxMenu *arg1 = (wxMenu *) 0 ;
33695 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33696 bool result;
33697 PyObject * obj0 = 0 ;
33698 PyObject * obj1 = 0 ;
33699 char *kwnames[] = {
33700 (char *) "self",(char *) "item", NULL
33701 };
33702
33703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33705 if (SWIG_arg_fail(1)) SWIG_fail;
33706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33707 if (SWIG_arg_fail(2)) SWIG_fail;
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (bool)(arg1)->Delete(arg2);
33711
33712 wxPyEndAllowThreads(__tstate);
33713 if (PyErr_Occurred()) SWIG_fail;
33714 }
33715 {
33716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33717 }
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj;
33726 wxMenu *arg1 = (wxMenu *) 0 ;
33727 PyObject * obj0 = 0 ;
33728 char *kwnames[] = {
33729 (char *) "self", NULL
33730 };
33731
33732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33734 if (SWIG_arg_fail(1)) SWIG_fail;
33735 {
33736 PyThreadState* __tstate = wxPyBeginAllowThreads();
33737 wxMenu_Destroy(arg1);
33738
33739 wxPyEndAllowThreads(__tstate);
33740 if (PyErr_Occurred()) SWIG_fail;
33741 }
33742 Py_INCREF(Py_None); resultobj = Py_None;
33743 return resultobj;
33744 fail:
33745 return NULL;
33746 }
33747
33748
33749 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33750 PyObject *resultobj;
33751 wxMenu *arg1 = (wxMenu *) 0 ;
33752 int arg2 ;
33753 bool result;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 char *kwnames[] = {
33757 (char *) "self",(char *) "id", NULL
33758 };
33759
33760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33762 if (SWIG_arg_fail(1)) SWIG_fail;
33763 {
33764 arg2 = (int)(SWIG_As_int(obj1));
33765 if (SWIG_arg_fail(2)) SWIG_fail;
33766 }
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 result = (bool)(arg1)->Destroy(arg2);
33770
33771 wxPyEndAllowThreads(__tstate);
33772 if (PyErr_Occurred()) SWIG_fail;
33773 }
33774 {
33775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33776 }
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33784 PyObject *resultobj;
33785 wxMenu *arg1 = (wxMenu *) 0 ;
33786 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33787 bool result;
33788 PyObject * obj0 = 0 ;
33789 PyObject * obj1 = 0 ;
33790 char *kwnames[] = {
33791 (char *) "self",(char *) "item", NULL
33792 };
33793
33794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33798 if (SWIG_arg_fail(2)) SWIG_fail;
33799 {
33800 PyThreadState* __tstate = wxPyBeginAllowThreads();
33801 result = (bool)(arg1)->Destroy(arg2);
33802
33803 wxPyEndAllowThreads(__tstate);
33804 if (PyErr_Occurred()) SWIG_fail;
33805 }
33806 {
33807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33808 }
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj;
33817 wxMenu *arg1 = (wxMenu *) 0 ;
33818 size_t result;
33819 PyObject * obj0 = 0 ;
33820 char *kwnames[] = {
33821 (char *) "self", NULL
33822 };
33823
33824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33826 if (SWIG_arg_fail(1)) SWIG_fail;
33827 {
33828 PyThreadState* __tstate = wxPyBeginAllowThreads();
33829 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33830
33831 wxPyEndAllowThreads(__tstate);
33832 if (PyErr_Occurred()) SWIG_fail;
33833 }
33834 {
33835 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33836 }
33837 return resultobj;
33838 fail:
33839 return NULL;
33840 }
33841
33842
33843 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33844 PyObject *resultobj;
33845 wxMenu *arg1 = (wxMenu *) 0 ;
33846 PyObject *result;
33847 PyObject * obj0 = 0 ;
33848 char *kwnames[] = {
33849 (char *) "self", NULL
33850 };
33851
33852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33854 if (SWIG_arg_fail(1)) SWIG_fail;
33855 {
33856 PyThreadState* __tstate = wxPyBeginAllowThreads();
33857 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33858
33859 wxPyEndAllowThreads(__tstate);
33860 if (PyErr_Occurred()) SWIG_fail;
33861 }
33862 resultobj = result;
33863 return resultobj;
33864 fail:
33865 return NULL;
33866 }
33867
33868
33869 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33870 PyObject *resultobj;
33871 wxMenu *arg1 = (wxMenu *) 0 ;
33872 wxString *arg2 = 0 ;
33873 int result;
33874 bool temp2 = false ;
33875 PyObject * obj0 = 0 ;
33876 PyObject * obj1 = 0 ;
33877 char *kwnames[] = {
33878 (char *) "self",(char *) "item", NULL
33879 };
33880
33881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33883 if (SWIG_arg_fail(1)) SWIG_fail;
33884 {
33885 arg2 = wxString_in_helper(obj1);
33886 if (arg2 == NULL) SWIG_fail;
33887 temp2 = true;
33888 }
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33892
33893 wxPyEndAllowThreads(__tstate);
33894 if (PyErr_Occurred()) SWIG_fail;
33895 }
33896 {
33897 resultobj = SWIG_From_int((int)(result));
33898 }
33899 {
33900 if (temp2)
33901 delete arg2;
33902 }
33903 return resultobj;
33904 fail:
33905 {
33906 if (temp2)
33907 delete arg2;
33908 }
33909 return NULL;
33910 }
33911
33912
33913 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33914 PyObject *resultobj;
33915 wxMenu *arg1 = (wxMenu *) 0 ;
33916 int arg2 ;
33917 wxMenuItem *result;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 char *kwnames[] = {
33921 (char *) "self",(char *) "id", NULL
33922 };
33923
33924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33926 if (SWIG_arg_fail(1)) SWIG_fail;
33927 {
33928 arg2 = (int)(SWIG_As_int(obj1));
33929 if (SWIG_arg_fail(2)) SWIG_fail;
33930 }
33931 {
33932 PyThreadState* __tstate = wxPyBeginAllowThreads();
33933 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33934
33935 wxPyEndAllowThreads(__tstate);
33936 if (PyErr_Occurred()) SWIG_fail;
33937 }
33938 {
33939 resultobj = wxPyMake_wxObject(result, 0);
33940 }
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj;
33949 wxMenu *arg1 = (wxMenu *) 0 ;
33950 size_t arg2 ;
33951 wxMenuItem *result;
33952 PyObject * obj0 = 0 ;
33953 PyObject * obj1 = 0 ;
33954 char *kwnames[] = {
33955 (char *) "self",(char *) "position", NULL
33956 };
33957
33958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33960 if (SWIG_arg_fail(1)) SWIG_fail;
33961 {
33962 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33963 if (SWIG_arg_fail(2)) SWIG_fail;
33964 }
33965 {
33966 PyThreadState* __tstate = wxPyBeginAllowThreads();
33967 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33968
33969 wxPyEndAllowThreads(__tstate);
33970 if (PyErr_Occurred()) SWIG_fail;
33971 }
33972 {
33973 resultobj = wxPyMake_wxObject(result, 0);
33974 }
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj;
33983 wxMenu *arg1 = (wxMenu *) 0 ;
33984 int arg2 ;
33985 bool arg3 ;
33986 PyObject * obj0 = 0 ;
33987 PyObject * obj1 = 0 ;
33988 PyObject * obj2 = 0 ;
33989 char *kwnames[] = {
33990 (char *) "self",(char *) "id",(char *) "enable", NULL
33991 };
33992
33993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33995 if (SWIG_arg_fail(1)) SWIG_fail;
33996 {
33997 arg2 = (int)(SWIG_As_int(obj1));
33998 if (SWIG_arg_fail(2)) SWIG_fail;
33999 }
34000 {
34001 arg3 = (bool)(SWIG_As_bool(obj2));
34002 if (SWIG_arg_fail(3)) SWIG_fail;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 (arg1)->Enable(arg2,arg3);
34007
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 Py_INCREF(Py_None); resultobj = Py_None;
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34019 PyObject *resultobj;
34020 wxMenu *arg1 = (wxMenu *) 0 ;
34021 int arg2 ;
34022 bool result;
34023 PyObject * obj0 = 0 ;
34024 PyObject * obj1 = 0 ;
34025 char *kwnames[] = {
34026 (char *) "self",(char *) "id", NULL
34027 };
34028
34029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34031 if (SWIG_arg_fail(1)) SWIG_fail;
34032 {
34033 arg2 = (int)(SWIG_As_int(obj1));
34034 if (SWIG_arg_fail(2)) SWIG_fail;
34035 }
34036 {
34037 PyThreadState* __tstate = wxPyBeginAllowThreads();
34038 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34039
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 {
34044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34045 }
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34053 PyObject *resultobj;
34054 wxMenu *arg1 = (wxMenu *) 0 ;
34055 int arg2 ;
34056 bool arg3 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 PyObject * obj2 = 0 ;
34060 char *kwnames[] = {
34061 (char *) "self",(char *) "id",(char *) "check", NULL
34062 };
34063
34064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34066 if (SWIG_arg_fail(1)) SWIG_fail;
34067 {
34068 arg2 = (int)(SWIG_As_int(obj1));
34069 if (SWIG_arg_fail(2)) SWIG_fail;
34070 }
34071 {
34072 arg3 = (bool)(SWIG_As_bool(obj2));
34073 if (SWIG_arg_fail(3)) SWIG_fail;
34074 }
34075 {
34076 PyThreadState* __tstate = wxPyBeginAllowThreads();
34077 (arg1)->Check(arg2,arg3);
34078
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 Py_INCREF(Py_None); resultobj = Py_None;
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj;
34091 wxMenu *arg1 = (wxMenu *) 0 ;
34092 int arg2 ;
34093 bool result;
34094 PyObject * obj0 = 0 ;
34095 PyObject * obj1 = 0 ;
34096 char *kwnames[] = {
34097 (char *) "self",(char *) "id", NULL
34098 };
34099
34100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34102 if (SWIG_arg_fail(1)) SWIG_fail;
34103 {
34104 arg2 = (int)(SWIG_As_int(obj1));
34105 if (SWIG_arg_fail(2)) SWIG_fail;
34106 }
34107 {
34108 PyThreadState* __tstate = wxPyBeginAllowThreads();
34109 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34110
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 {
34115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34116 }
34117 return resultobj;
34118 fail:
34119 return NULL;
34120 }
34121
34122
34123 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34124 PyObject *resultobj;
34125 wxMenu *arg1 = (wxMenu *) 0 ;
34126 int arg2 ;
34127 wxString *arg3 = 0 ;
34128 bool temp3 = false ;
34129 PyObject * obj0 = 0 ;
34130 PyObject * obj1 = 0 ;
34131 PyObject * obj2 = 0 ;
34132 char *kwnames[] = {
34133 (char *) "self",(char *) "id",(char *) "label", NULL
34134 };
34135
34136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34138 if (SWIG_arg_fail(1)) SWIG_fail;
34139 {
34140 arg2 = (int)(SWIG_As_int(obj1));
34141 if (SWIG_arg_fail(2)) SWIG_fail;
34142 }
34143 {
34144 arg3 = wxString_in_helper(obj2);
34145 if (arg3 == NULL) SWIG_fail;
34146 temp3 = true;
34147 }
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34151
34152 wxPyEndAllowThreads(__tstate);
34153 if (PyErr_Occurred()) SWIG_fail;
34154 }
34155 Py_INCREF(Py_None); resultobj = Py_None;
34156 {
34157 if (temp3)
34158 delete arg3;
34159 }
34160 return resultobj;
34161 fail:
34162 {
34163 if (temp3)
34164 delete arg3;
34165 }
34166 return NULL;
34167 }
34168
34169
34170 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj;
34172 wxMenu *arg1 = (wxMenu *) 0 ;
34173 int arg2 ;
34174 wxString result;
34175 PyObject * obj0 = 0 ;
34176 PyObject * obj1 = 0 ;
34177 char *kwnames[] = {
34178 (char *) "self",(char *) "id", NULL
34179 };
34180
34181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34183 if (SWIG_arg_fail(1)) SWIG_fail;
34184 {
34185 arg2 = (int)(SWIG_As_int(obj1));
34186 if (SWIG_arg_fail(2)) SWIG_fail;
34187 }
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34191
34192 wxPyEndAllowThreads(__tstate);
34193 if (PyErr_Occurred()) SWIG_fail;
34194 }
34195 {
34196 #if wxUSE_UNICODE
34197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34198 #else
34199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34200 #endif
34201 }
34202 return resultobj;
34203 fail:
34204 return NULL;
34205 }
34206
34207
34208 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34209 PyObject *resultobj;
34210 wxMenu *arg1 = (wxMenu *) 0 ;
34211 int arg2 ;
34212 wxString *arg3 = 0 ;
34213 bool temp3 = false ;
34214 PyObject * obj0 = 0 ;
34215 PyObject * obj1 = 0 ;
34216 PyObject * obj2 = 0 ;
34217 char *kwnames[] = {
34218 (char *) "self",(char *) "id",(char *) "helpString", NULL
34219 };
34220
34221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34223 if (SWIG_arg_fail(1)) SWIG_fail;
34224 {
34225 arg2 = (int)(SWIG_As_int(obj1));
34226 if (SWIG_arg_fail(2)) SWIG_fail;
34227 }
34228 {
34229 arg3 = wxString_in_helper(obj2);
34230 if (arg3 == NULL) SWIG_fail;
34231 temp3 = true;
34232 }
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34236
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 Py_INCREF(Py_None); resultobj = Py_None;
34241 {
34242 if (temp3)
34243 delete arg3;
34244 }
34245 return resultobj;
34246 fail:
34247 {
34248 if (temp3)
34249 delete arg3;
34250 }
34251 return NULL;
34252 }
34253
34254
34255 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34256 PyObject *resultobj;
34257 wxMenu *arg1 = (wxMenu *) 0 ;
34258 int arg2 ;
34259 wxString result;
34260 PyObject * obj0 = 0 ;
34261 PyObject * obj1 = 0 ;
34262 char *kwnames[] = {
34263 (char *) "self",(char *) "id", NULL
34264 };
34265
34266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34268 if (SWIG_arg_fail(1)) SWIG_fail;
34269 {
34270 arg2 = (int)(SWIG_As_int(obj1));
34271 if (SWIG_arg_fail(2)) SWIG_fail;
34272 }
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34276
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 {
34281 #if wxUSE_UNICODE
34282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34283 #else
34284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34285 #endif
34286 }
34287 return resultobj;
34288 fail:
34289 return NULL;
34290 }
34291
34292
34293 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34294 PyObject *resultobj;
34295 wxMenu *arg1 = (wxMenu *) 0 ;
34296 wxString *arg2 = 0 ;
34297 bool temp2 = false ;
34298 PyObject * obj0 = 0 ;
34299 PyObject * obj1 = 0 ;
34300 char *kwnames[] = {
34301 (char *) "self",(char *) "title", NULL
34302 };
34303
34304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34306 if (SWIG_arg_fail(1)) SWIG_fail;
34307 {
34308 arg2 = wxString_in_helper(obj1);
34309 if (arg2 == NULL) SWIG_fail;
34310 temp2 = true;
34311 }
34312 {
34313 PyThreadState* __tstate = wxPyBeginAllowThreads();
34314 (arg1)->SetTitle((wxString const &)*arg2);
34315
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 Py_INCREF(Py_None); resultobj = Py_None;
34320 {
34321 if (temp2)
34322 delete arg2;
34323 }
34324 return resultobj;
34325 fail:
34326 {
34327 if (temp2)
34328 delete arg2;
34329 }
34330 return NULL;
34331 }
34332
34333
34334 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34335 PyObject *resultobj;
34336 wxMenu *arg1 = (wxMenu *) 0 ;
34337 wxString result;
34338 PyObject * obj0 = 0 ;
34339 char *kwnames[] = {
34340 (char *) "self", NULL
34341 };
34342
34343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34345 if (SWIG_arg_fail(1)) SWIG_fail;
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 result = ((wxMenu const *)arg1)->GetTitle();
34349
34350 wxPyEndAllowThreads(__tstate);
34351 if (PyErr_Occurred()) SWIG_fail;
34352 }
34353 {
34354 #if wxUSE_UNICODE
34355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34356 #else
34357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34358 #endif
34359 }
34360 return resultobj;
34361 fail:
34362 return NULL;
34363 }
34364
34365
34366 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34367 PyObject *resultobj;
34368 wxMenu *arg1 = (wxMenu *) 0 ;
34369 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34370 PyObject * obj0 = 0 ;
34371 PyObject * obj1 = 0 ;
34372 char *kwnames[] = {
34373 (char *) "self",(char *) "handler", NULL
34374 };
34375
34376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34378 if (SWIG_arg_fail(1)) SWIG_fail;
34379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34380 if (SWIG_arg_fail(2)) SWIG_fail;
34381 {
34382 PyThreadState* __tstate = wxPyBeginAllowThreads();
34383 (arg1)->SetEventHandler(arg2);
34384
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 Py_INCREF(Py_None); resultobj = Py_None;
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34396 PyObject *resultobj;
34397 wxMenu *arg1 = (wxMenu *) 0 ;
34398 wxEvtHandler *result;
34399 PyObject * obj0 = 0 ;
34400 char *kwnames[] = {
34401 (char *) "self", NULL
34402 };
34403
34404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34406 if (SWIG_arg_fail(1)) SWIG_fail;
34407 {
34408 PyThreadState* __tstate = wxPyBeginAllowThreads();
34409 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34410
34411 wxPyEndAllowThreads(__tstate);
34412 if (PyErr_Occurred()) SWIG_fail;
34413 }
34414 {
34415 resultobj = wxPyMake_wxObject(result, 0);
34416 }
34417 return resultobj;
34418 fail:
34419 return NULL;
34420 }
34421
34422
34423 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34424 PyObject *resultobj;
34425 wxMenu *arg1 = (wxMenu *) 0 ;
34426 wxWindow *arg2 = (wxWindow *) 0 ;
34427 PyObject * obj0 = 0 ;
34428 PyObject * obj1 = 0 ;
34429 char *kwnames[] = {
34430 (char *) "self",(char *) "win", NULL
34431 };
34432
34433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34435 if (SWIG_arg_fail(1)) SWIG_fail;
34436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34437 if (SWIG_arg_fail(2)) SWIG_fail;
34438 {
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 (arg1)->SetInvokingWindow(arg2);
34441
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 Py_INCREF(Py_None); resultobj = Py_None;
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34453 PyObject *resultobj;
34454 wxMenu *arg1 = (wxMenu *) 0 ;
34455 wxWindow *result;
34456 PyObject * obj0 = 0 ;
34457 char *kwnames[] = {
34458 (char *) "self", NULL
34459 };
34460
34461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34463 if (SWIG_arg_fail(1)) SWIG_fail;
34464 {
34465 PyThreadState* __tstate = wxPyBeginAllowThreads();
34466 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34467
34468 wxPyEndAllowThreads(__tstate);
34469 if (PyErr_Occurred()) SWIG_fail;
34470 }
34471 {
34472 resultobj = wxPyMake_wxObject(result, 0);
34473 }
34474 return resultobj;
34475 fail:
34476 return NULL;
34477 }
34478
34479
34480 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34481 PyObject *resultobj;
34482 wxMenu *arg1 = (wxMenu *) 0 ;
34483 long result;
34484 PyObject * obj0 = 0 ;
34485 char *kwnames[] = {
34486 (char *) "self", NULL
34487 };
34488
34489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34491 if (SWIG_arg_fail(1)) SWIG_fail;
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 result = (long)((wxMenu const *)arg1)->GetStyle();
34495
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 {
34500 resultobj = SWIG_From_long((long)(result));
34501 }
34502 return resultobj;
34503 fail:
34504 return NULL;
34505 }
34506
34507
34508 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34509 PyObject *resultobj;
34510 wxMenu *arg1 = (wxMenu *) 0 ;
34511 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34512 PyObject * obj0 = 0 ;
34513 PyObject * obj1 = 0 ;
34514 char *kwnames[] = {
34515 (char *) "self",(char *) "source", NULL
34516 };
34517
34518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34520 if (SWIG_arg_fail(1)) SWIG_fail;
34521 if (obj1) {
34522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34523 if (SWIG_arg_fail(2)) SWIG_fail;
34524 }
34525 {
34526 PyThreadState* __tstate = wxPyBeginAllowThreads();
34527 (arg1)->UpdateUI(arg2);
34528
34529 wxPyEndAllowThreads(__tstate);
34530 if (PyErr_Occurred()) SWIG_fail;
34531 }
34532 Py_INCREF(Py_None); resultobj = Py_None;
34533 return resultobj;
34534 fail:
34535 return NULL;
34536 }
34537
34538
34539 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34540 PyObject *resultobj;
34541 wxMenu *arg1 = (wxMenu *) 0 ;
34542 wxMenuBar *result;
34543 PyObject * obj0 = 0 ;
34544 char *kwnames[] = {
34545 (char *) "self", NULL
34546 };
34547
34548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34550 if (SWIG_arg_fail(1)) SWIG_fail;
34551 {
34552 PyThreadState* __tstate = wxPyBeginAllowThreads();
34553 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34554
34555 wxPyEndAllowThreads(__tstate);
34556 if (PyErr_Occurred()) SWIG_fail;
34557 }
34558 {
34559 resultobj = wxPyMake_wxObject(result, 0);
34560 }
34561 return resultobj;
34562 fail:
34563 return NULL;
34564 }
34565
34566
34567 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34568 PyObject *resultobj;
34569 wxMenu *arg1 = (wxMenu *) 0 ;
34570 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34571 PyObject * obj0 = 0 ;
34572 PyObject * obj1 = 0 ;
34573 char *kwnames[] = {
34574 (char *) "self",(char *) "menubar", NULL
34575 };
34576
34577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34579 if (SWIG_arg_fail(1)) SWIG_fail;
34580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34581 if (SWIG_arg_fail(2)) SWIG_fail;
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 (arg1)->Attach(arg2);
34585
34586 wxPyEndAllowThreads(__tstate);
34587 if (PyErr_Occurred()) SWIG_fail;
34588 }
34589 Py_INCREF(Py_None); resultobj = Py_None;
34590 return resultobj;
34591 fail:
34592 return NULL;
34593 }
34594
34595
34596 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34597 PyObject *resultobj;
34598 wxMenu *arg1 = (wxMenu *) 0 ;
34599 PyObject * obj0 = 0 ;
34600 char *kwnames[] = {
34601 (char *) "self", NULL
34602 };
34603
34604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34606 if (SWIG_arg_fail(1)) SWIG_fail;
34607 {
34608 PyThreadState* __tstate = wxPyBeginAllowThreads();
34609 (arg1)->Detach();
34610
34611 wxPyEndAllowThreads(__tstate);
34612 if (PyErr_Occurred()) SWIG_fail;
34613 }
34614 Py_INCREF(Py_None); resultobj = Py_None;
34615 return resultobj;
34616 fail:
34617 return NULL;
34618 }
34619
34620
34621 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34622 PyObject *resultobj;
34623 wxMenu *arg1 = (wxMenu *) 0 ;
34624 bool result;
34625 PyObject * obj0 = 0 ;
34626 char *kwnames[] = {
34627 (char *) "self", NULL
34628 };
34629
34630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34632 if (SWIG_arg_fail(1)) SWIG_fail;
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 result = (bool)((wxMenu const *)arg1)->IsAttached();
34636
34637 wxPyEndAllowThreads(__tstate);
34638 if (PyErr_Occurred()) SWIG_fail;
34639 }
34640 {
34641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34642 }
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34650 PyObject *resultobj;
34651 wxMenu *arg1 = (wxMenu *) 0 ;
34652 wxMenu *arg2 = (wxMenu *) 0 ;
34653 PyObject * obj0 = 0 ;
34654 PyObject * obj1 = 0 ;
34655 char *kwnames[] = {
34656 (char *) "self",(char *) "parent", NULL
34657 };
34658
34659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34661 if (SWIG_arg_fail(1)) SWIG_fail;
34662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34663 if (SWIG_arg_fail(2)) SWIG_fail;
34664 {
34665 PyThreadState* __tstate = wxPyBeginAllowThreads();
34666 (arg1)->SetParent(arg2);
34667
34668 wxPyEndAllowThreads(__tstate);
34669 if (PyErr_Occurred()) SWIG_fail;
34670 }
34671 Py_INCREF(Py_None); resultobj = Py_None;
34672 return resultobj;
34673 fail:
34674 return NULL;
34675 }
34676
34677
34678 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34679 PyObject *resultobj;
34680 wxMenu *arg1 = (wxMenu *) 0 ;
34681 wxMenu *result;
34682 PyObject * obj0 = 0 ;
34683 char *kwnames[] = {
34684 (char *) "self", NULL
34685 };
34686
34687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34689 if (SWIG_arg_fail(1)) SWIG_fail;
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34693
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 {
34698 resultobj = wxPyMake_wxObject(result, 0);
34699 }
34700 return resultobj;
34701 fail:
34702 return NULL;
34703 }
34704
34705
34706 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34707 PyObject *obj;
34708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34709 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34710 Py_INCREF(obj);
34711 return Py_BuildValue((char *)"");
34712 }
34713 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34714 PyObject *resultobj;
34715 long arg1 = (long) 0 ;
34716 wxMenuBar *result;
34717 PyObject * obj0 = 0 ;
34718 char *kwnames[] = {
34719 (char *) "style", NULL
34720 };
34721
34722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34723 if (obj0) {
34724 {
34725 arg1 = (long)(SWIG_As_long(obj0));
34726 if (SWIG_arg_fail(1)) SWIG_fail;
34727 }
34728 }
34729 {
34730 if (!wxPyCheckForApp()) SWIG_fail;
34731 PyThreadState* __tstate = wxPyBeginAllowThreads();
34732 result = (wxMenuBar *)new wxMenuBar(arg1);
34733
34734 wxPyEndAllowThreads(__tstate);
34735 if (PyErr_Occurred()) SWIG_fail;
34736 }
34737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34738 return resultobj;
34739 fail:
34740 return NULL;
34741 }
34742
34743
34744 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34745 PyObject *resultobj;
34746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34747 wxMenu *arg2 = (wxMenu *) 0 ;
34748 wxString *arg3 = 0 ;
34749 bool result;
34750 bool temp3 = false ;
34751 PyObject * obj0 = 0 ;
34752 PyObject * obj1 = 0 ;
34753 PyObject * obj2 = 0 ;
34754 char *kwnames[] = {
34755 (char *) "self",(char *) "menu",(char *) "title", NULL
34756 };
34757
34758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34760 if (SWIG_arg_fail(1)) SWIG_fail;
34761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34762 if (SWIG_arg_fail(2)) SWIG_fail;
34763 {
34764 arg3 = wxString_in_helper(obj2);
34765 if (arg3 == NULL) SWIG_fail;
34766 temp3 = true;
34767 }
34768 {
34769 PyThreadState* __tstate = wxPyBeginAllowThreads();
34770 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34771
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34777 }
34778 {
34779 if (temp3)
34780 delete arg3;
34781 }
34782 return resultobj;
34783 fail:
34784 {
34785 if (temp3)
34786 delete arg3;
34787 }
34788 return NULL;
34789 }
34790
34791
34792 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34793 PyObject *resultobj;
34794 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34795 size_t arg2 ;
34796 wxMenu *arg3 = (wxMenu *) 0 ;
34797 wxString *arg4 = 0 ;
34798 bool result;
34799 bool temp4 = false ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 PyObject * obj2 = 0 ;
34803 PyObject * obj3 = 0 ;
34804 char *kwnames[] = {
34805 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34806 };
34807
34808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34810 if (SWIG_arg_fail(1)) SWIG_fail;
34811 {
34812 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34813 if (SWIG_arg_fail(2)) SWIG_fail;
34814 }
34815 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34816 if (SWIG_arg_fail(3)) SWIG_fail;
34817 {
34818 arg4 = wxString_in_helper(obj3);
34819 if (arg4 == NULL) SWIG_fail;
34820 temp4 = true;
34821 }
34822 {
34823 PyThreadState* __tstate = wxPyBeginAllowThreads();
34824 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34825
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 {
34830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34831 }
34832 {
34833 if (temp4)
34834 delete arg4;
34835 }
34836 return resultobj;
34837 fail:
34838 {
34839 if (temp4)
34840 delete arg4;
34841 }
34842 return NULL;
34843 }
34844
34845
34846 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj;
34848 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34849 size_t result;
34850 PyObject * obj0 = 0 ;
34851 char *kwnames[] = {
34852 (char *) "self", NULL
34853 };
34854
34855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34857 if (SWIG_arg_fail(1)) SWIG_fail;
34858 {
34859 PyThreadState* __tstate = wxPyBeginAllowThreads();
34860 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34861
34862 wxPyEndAllowThreads(__tstate);
34863 if (PyErr_Occurred()) SWIG_fail;
34864 }
34865 {
34866 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34867 }
34868 return resultobj;
34869 fail:
34870 return NULL;
34871 }
34872
34873
34874 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34875 PyObject *resultobj;
34876 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34877 size_t arg2 ;
34878 wxMenu *result;
34879 PyObject * obj0 = 0 ;
34880 PyObject * obj1 = 0 ;
34881 char *kwnames[] = {
34882 (char *) "self",(char *) "pos", NULL
34883 };
34884
34885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34887 if (SWIG_arg_fail(1)) SWIG_fail;
34888 {
34889 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34890 if (SWIG_arg_fail(2)) SWIG_fail;
34891 }
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34895
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = wxPyMake_wxObject(result, 0);
34901 }
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34909 PyObject *resultobj;
34910 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34911 size_t arg2 ;
34912 wxMenu *arg3 = (wxMenu *) 0 ;
34913 wxString *arg4 = 0 ;
34914 wxMenu *result;
34915 bool temp4 = false ;
34916 PyObject * obj0 = 0 ;
34917 PyObject * obj1 = 0 ;
34918 PyObject * obj2 = 0 ;
34919 PyObject * obj3 = 0 ;
34920 char *kwnames[] = {
34921 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34922 };
34923
34924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34926 if (SWIG_arg_fail(1)) SWIG_fail;
34927 {
34928 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34929 if (SWIG_arg_fail(2)) SWIG_fail;
34930 }
34931 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34932 if (SWIG_arg_fail(3)) SWIG_fail;
34933 {
34934 arg4 = wxString_in_helper(obj3);
34935 if (arg4 == NULL) SWIG_fail;
34936 temp4 = true;
34937 }
34938 {
34939 PyThreadState* __tstate = wxPyBeginAllowThreads();
34940 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34941
34942 wxPyEndAllowThreads(__tstate);
34943 if (PyErr_Occurred()) SWIG_fail;
34944 }
34945 {
34946 resultobj = wxPyMake_wxObject(result, 0);
34947 }
34948 {
34949 if (temp4)
34950 delete arg4;
34951 }
34952 return resultobj;
34953 fail:
34954 {
34955 if (temp4)
34956 delete arg4;
34957 }
34958 return NULL;
34959 }
34960
34961
34962 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34963 PyObject *resultobj;
34964 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34965 size_t arg2 ;
34966 wxMenu *result;
34967 PyObject * obj0 = 0 ;
34968 PyObject * obj1 = 0 ;
34969 char *kwnames[] = {
34970 (char *) "self",(char *) "pos", NULL
34971 };
34972
34973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34975 if (SWIG_arg_fail(1)) SWIG_fail;
34976 {
34977 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34978 if (SWIG_arg_fail(2)) SWIG_fail;
34979 }
34980 {
34981 PyThreadState* __tstate = wxPyBeginAllowThreads();
34982 result = (wxMenu *)(arg1)->Remove(arg2);
34983
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 {
34988 resultobj = wxPyMake_wxObject(result, 0);
34989 }
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34997 PyObject *resultobj;
34998 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34999 size_t arg2 ;
35000 bool arg3 ;
35001 PyObject * obj0 = 0 ;
35002 PyObject * obj1 = 0 ;
35003 PyObject * obj2 = 0 ;
35004 char *kwnames[] = {
35005 (char *) "self",(char *) "pos",(char *) "enable", NULL
35006 };
35007
35008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35010 if (SWIG_arg_fail(1)) SWIG_fail;
35011 {
35012 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35013 if (SWIG_arg_fail(2)) SWIG_fail;
35014 }
35015 {
35016 arg3 = (bool)(SWIG_As_bool(obj2));
35017 if (SWIG_arg_fail(3)) SWIG_fail;
35018 }
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 (arg1)->EnableTop(arg2,arg3);
35022
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 Py_INCREF(Py_None); resultobj = Py_None;
35027 return resultobj;
35028 fail:
35029 return NULL;
35030 }
35031
35032
35033 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35034 PyObject *resultobj;
35035 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35036 size_t arg2 ;
35037 bool result;
35038 PyObject * obj0 = 0 ;
35039 PyObject * obj1 = 0 ;
35040 char *kwnames[] = {
35041 (char *) "self",(char *) "pos", NULL
35042 };
35043
35044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35046 if (SWIG_arg_fail(1)) SWIG_fail;
35047 {
35048 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35049 if (SWIG_arg_fail(2)) SWIG_fail;
35050 }
35051 {
35052 PyThreadState* __tstate = wxPyBeginAllowThreads();
35053 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35054
35055 wxPyEndAllowThreads(__tstate);
35056 if (PyErr_Occurred()) SWIG_fail;
35057 }
35058 {
35059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35060 }
35061 return resultobj;
35062 fail:
35063 return NULL;
35064 }
35065
35066
35067 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35068 PyObject *resultobj;
35069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35070 size_t arg2 ;
35071 wxString *arg3 = 0 ;
35072 bool temp3 = false ;
35073 PyObject * obj0 = 0 ;
35074 PyObject * obj1 = 0 ;
35075 PyObject * obj2 = 0 ;
35076 char *kwnames[] = {
35077 (char *) "self",(char *) "pos",(char *) "label", NULL
35078 };
35079
35080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35082 if (SWIG_arg_fail(1)) SWIG_fail;
35083 {
35084 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35085 if (SWIG_arg_fail(2)) SWIG_fail;
35086 }
35087 {
35088 arg3 = wxString_in_helper(obj2);
35089 if (arg3 == NULL) SWIG_fail;
35090 temp3 = true;
35091 }
35092 {
35093 PyThreadState* __tstate = wxPyBeginAllowThreads();
35094 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35095
35096 wxPyEndAllowThreads(__tstate);
35097 if (PyErr_Occurred()) SWIG_fail;
35098 }
35099 Py_INCREF(Py_None); resultobj = Py_None;
35100 {
35101 if (temp3)
35102 delete arg3;
35103 }
35104 return resultobj;
35105 fail:
35106 {
35107 if (temp3)
35108 delete arg3;
35109 }
35110 return NULL;
35111 }
35112
35113
35114 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj;
35116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35117 size_t arg2 ;
35118 wxString result;
35119 PyObject * obj0 = 0 ;
35120 PyObject * obj1 = 0 ;
35121 char *kwnames[] = {
35122 (char *) "self",(char *) "pos", NULL
35123 };
35124
35125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35127 if (SWIG_arg_fail(1)) SWIG_fail;
35128 {
35129 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35130 if (SWIG_arg_fail(2)) SWIG_fail;
35131 }
35132 {
35133 PyThreadState* __tstate = wxPyBeginAllowThreads();
35134 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35135
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 {
35140 #if wxUSE_UNICODE
35141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35142 #else
35143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35144 #endif
35145 }
35146 return resultobj;
35147 fail:
35148 return NULL;
35149 }
35150
35151
35152 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35153 PyObject *resultobj;
35154 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35155 wxString *arg2 = 0 ;
35156 wxString *arg3 = 0 ;
35157 int result;
35158 bool temp2 = false ;
35159 bool temp3 = false ;
35160 PyObject * obj0 = 0 ;
35161 PyObject * obj1 = 0 ;
35162 PyObject * obj2 = 0 ;
35163 char *kwnames[] = {
35164 (char *) "self",(char *) "menu",(char *) "item", NULL
35165 };
35166
35167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35169 if (SWIG_arg_fail(1)) SWIG_fail;
35170 {
35171 arg2 = wxString_in_helper(obj1);
35172 if (arg2 == NULL) SWIG_fail;
35173 temp2 = true;
35174 }
35175 {
35176 arg3 = wxString_in_helper(obj2);
35177 if (arg3 == NULL) SWIG_fail;
35178 temp3 = true;
35179 }
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35183
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 {
35188 resultobj = SWIG_From_int((int)(result));
35189 }
35190 {
35191 if (temp2)
35192 delete arg2;
35193 }
35194 {
35195 if (temp3)
35196 delete arg3;
35197 }
35198 return resultobj;
35199 fail:
35200 {
35201 if (temp2)
35202 delete arg2;
35203 }
35204 {
35205 if (temp3)
35206 delete arg3;
35207 }
35208 return NULL;
35209 }
35210
35211
35212 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35213 PyObject *resultobj;
35214 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35215 int arg2 ;
35216 wxMenuItem *result;
35217 PyObject * obj0 = 0 ;
35218 PyObject * obj1 = 0 ;
35219 char *kwnames[] = {
35220 (char *) "self",(char *) "id", NULL
35221 };
35222
35223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35225 if (SWIG_arg_fail(1)) SWIG_fail;
35226 {
35227 arg2 = (int)(SWIG_As_int(obj1));
35228 if (SWIG_arg_fail(2)) SWIG_fail;
35229 }
35230 {
35231 PyThreadState* __tstate = wxPyBeginAllowThreads();
35232 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35233
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 {
35238 resultobj = wxPyMake_wxObject(result, 0);
35239 }
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35247 PyObject *resultobj;
35248 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35249 wxString *arg2 = 0 ;
35250 int result;
35251 bool temp2 = false ;
35252 PyObject * obj0 = 0 ;
35253 PyObject * obj1 = 0 ;
35254 char *kwnames[] = {
35255 (char *) "self",(char *) "title", NULL
35256 };
35257
35258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35260 if (SWIG_arg_fail(1)) SWIG_fail;
35261 {
35262 arg2 = wxString_in_helper(obj1);
35263 if (arg2 == NULL) SWIG_fail;
35264 temp2 = true;
35265 }
35266 {
35267 PyThreadState* __tstate = wxPyBeginAllowThreads();
35268 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35269
35270 wxPyEndAllowThreads(__tstate);
35271 if (PyErr_Occurred()) SWIG_fail;
35272 }
35273 {
35274 resultobj = SWIG_From_int((int)(result));
35275 }
35276 {
35277 if (temp2)
35278 delete arg2;
35279 }
35280 return resultobj;
35281 fail:
35282 {
35283 if (temp2)
35284 delete arg2;
35285 }
35286 return NULL;
35287 }
35288
35289
35290 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35291 PyObject *resultobj;
35292 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35293 int arg2 ;
35294 bool arg3 ;
35295 PyObject * obj0 = 0 ;
35296 PyObject * obj1 = 0 ;
35297 PyObject * obj2 = 0 ;
35298 char *kwnames[] = {
35299 (char *) "self",(char *) "id",(char *) "enable", NULL
35300 };
35301
35302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35304 if (SWIG_arg_fail(1)) SWIG_fail;
35305 {
35306 arg2 = (int)(SWIG_As_int(obj1));
35307 if (SWIG_arg_fail(2)) SWIG_fail;
35308 }
35309 {
35310 arg3 = (bool)(SWIG_As_bool(obj2));
35311 if (SWIG_arg_fail(3)) SWIG_fail;
35312 }
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 (arg1)->Enable(arg2,arg3);
35316
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 Py_INCREF(Py_None); resultobj = Py_None;
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35328 PyObject *resultobj;
35329 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35330 int arg2 ;
35331 bool arg3 ;
35332 PyObject * obj0 = 0 ;
35333 PyObject * obj1 = 0 ;
35334 PyObject * obj2 = 0 ;
35335 char *kwnames[] = {
35336 (char *) "self",(char *) "id",(char *) "check", NULL
35337 };
35338
35339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35341 if (SWIG_arg_fail(1)) SWIG_fail;
35342 {
35343 arg2 = (int)(SWIG_As_int(obj1));
35344 if (SWIG_arg_fail(2)) SWIG_fail;
35345 }
35346 {
35347 arg3 = (bool)(SWIG_As_bool(obj2));
35348 if (SWIG_arg_fail(3)) SWIG_fail;
35349 }
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 (arg1)->Check(arg2,arg3);
35353
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 Py_INCREF(Py_None); resultobj = Py_None;
35358 return resultobj;
35359 fail:
35360 return NULL;
35361 }
35362
35363
35364 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35365 PyObject *resultobj;
35366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35367 int arg2 ;
35368 bool result;
35369 PyObject * obj0 = 0 ;
35370 PyObject * obj1 = 0 ;
35371 char *kwnames[] = {
35372 (char *) "self",(char *) "id", NULL
35373 };
35374
35375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35377 if (SWIG_arg_fail(1)) SWIG_fail;
35378 {
35379 arg2 = (int)(SWIG_As_int(obj1));
35380 if (SWIG_arg_fail(2)) SWIG_fail;
35381 }
35382 {
35383 PyThreadState* __tstate = wxPyBeginAllowThreads();
35384 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35385
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 {
35390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35391 }
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj;
35400 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35401 int arg2 ;
35402 bool result;
35403 PyObject * obj0 = 0 ;
35404 PyObject * obj1 = 0 ;
35405 char *kwnames[] = {
35406 (char *) "self",(char *) "id", NULL
35407 };
35408
35409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35411 if (SWIG_arg_fail(1)) SWIG_fail;
35412 {
35413 arg2 = (int)(SWIG_As_int(obj1));
35414 if (SWIG_arg_fail(2)) SWIG_fail;
35415 }
35416 {
35417 PyThreadState* __tstate = wxPyBeginAllowThreads();
35418 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35419
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 {
35424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35425 }
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35433 PyObject *resultobj;
35434 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35435 int arg2 ;
35436 wxString *arg3 = 0 ;
35437 bool temp3 = false ;
35438 PyObject * obj0 = 0 ;
35439 PyObject * obj1 = 0 ;
35440 PyObject * obj2 = 0 ;
35441 char *kwnames[] = {
35442 (char *) "self",(char *) "id",(char *) "label", NULL
35443 };
35444
35445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35447 if (SWIG_arg_fail(1)) SWIG_fail;
35448 {
35449 arg2 = (int)(SWIG_As_int(obj1));
35450 if (SWIG_arg_fail(2)) SWIG_fail;
35451 }
35452 {
35453 arg3 = wxString_in_helper(obj2);
35454 if (arg3 == NULL) SWIG_fail;
35455 temp3 = true;
35456 }
35457 {
35458 PyThreadState* __tstate = wxPyBeginAllowThreads();
35459 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35460
35461 wxPyEndAllowThreads(__tstate);
35462 if (PyErr_Occurred()) SWIG_fail;
35463 }
35464 Py_INCREF(Py_None); resultobj = Py_None;
35465 {
35466 if (temp3)
35467 delete arg3;
35468 }
35469 return resultobj;
35470 fail:
35471 {
35472 if (temp3)
35473 delete arg3;
35474 }
35475 return NULL;
35476 }
35477
35478
35479 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35480 PyObject *resultobj;
35481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35482 int arg2 ;
35483 wxString result;
35484 PyObject * obj0 = 0 ;
35485 PyObject * obj1 = 0 ;
35486 char *kwnames[] = {
35487 (char *) "self",(char *) "id", NULL
35488 };
35489
35490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35492 if (SWIG_arg_fail(1)) SWIG_fail;
35493 {
35494 arg2 = (int)(SWIG_As_int(obj1));
35495 if (SWIG_arg_fail(2)) SWIG_fail;
35496 }
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35500
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 {
35505 #if wxUSE_UNICODE
35506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35507 #else
35508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35509 #endif
35510 }
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj;
35519 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35520 int arg2 ;
35521 wxString *arg3 = 0 ;
35522 bool temp3 = false ;
35523 PyObject * obj0 = 0 ;
35524 PyObject * obj1 = 0 ;
35525 PyObject * obj2 = 0 ;
35526 char *kwnames[] = {
35527 (char *) "self",(char *) "id",(char *) "helpString", NULL
35528 };
35529
35530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35532 if (SWIG_arg_fail(1)) SWIG_fail;
35533 {
35534 arg2 = (int)(SWIG_As_int(obj1));
35535 if (SWIG_arg_fail(2)) SWIG_fail;
35536 }
35537 {
35538 arg3 = wxString_in_helper(obj2);
35539 if (arg3 == NULL) SWIG_fail;
35540 temp3 = true;
35541 }
35542 {
35543 PyThreadState* __tstate = wxPyBeginAllowThreads();
35544 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35545
35546 wxPyEndAllowThreads(__tstate);
35547 if (PyErr_Occurred()) SWIG_fail;
35548 }
35549 Py_INCREF(Py_None); resultobj = Py_None;
35550 {
35551 if (temp3)
35552 delete arg3;
35553 }
35554 return resultobj;
35555 fail:
35556 {
35557 if (temp3)
35558 delete arg3;
35559 }
35560 return NULL;
35561 }
35562
35563
35564 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35565 PyObject *resultobj;
35566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35567 int arg2 ;
35568 wxString result;
35569 PyObject * obj0 = 0 ;
35570 PyObject * obj1 = 0 ;
35571 char *kwnames[] = {
35572 (char *) "self",(char *) "id", NULL
35573 };
35574
35575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35577 if (SWIG_arg_fail(1)) SWIG_fail;
35578 {
35579 arg2 = (int)(SWIG_As_int(obj1));
35580 if (SWIG_arg_fail(2)) SWIG_fail;
35581 }
35582 {
35583 PyThreadState* __tstate = wxPyBeginAllowThreads();
35584 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35585
35586 wxPyEndAllowThreads(__tstate);
35587 if (PyErr_Occurred()) SWIG_fail;
35588 }
35589 {
35590 #if wxUSE_UNICODE
35591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35592 #else
35593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35594 #endif
35595 }
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35603 PyObject *resultobj;
35604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35605 wxFrame *result;
35606 PyObject * obj0 = 0 ;
35607 char *kwnames[] = {
35608 (char *) "self", NULL
35609 };
35610
35611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35613 if (SWIG_arg_fail(1)) SWIG_fail;
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35617
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 {
35622 resultobj = wxPyMake_wxObject(result, 0);
35623 }
35624 return resultobj;
35625 fail:
35626 return NULL;
35627 }
35628
35629
35630 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35631 PyObject *resultobj;
35632 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35633 bool result;
35634 PyObject * obj0 = 0 ;
35635 char *kwnames[] = {
35636 (char *) "self", NULL
35637 };
35638
35639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35641 if (SWIG_arg_fail(1)) SWIG_fail;
35642 {
35643 PyThreadState* __tstate = wxPyBeginAllowThreads();
35644 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35645
35646 wxPyEndAllowThreads(__tstate);
35647 if (PyErr_Occurred()) SWIG_fail;
35648 }
35649 {
35650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35651 }
35652 return resultobj;
35653 fail:
35654 return NULL;
35655 }
35656
35657
35658 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35659 PyObject *resultobj;
35660 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35661 wxFrame *arg2 = (wxFrame *) 0 ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 char *kwnames[] = {
35665 (char *) "self",(char *) "frame", NULL
35666 };
35667
35668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35670 if (SWIG_arg_fail(1)) SWIG_fail;
35671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35672 if (SWIG_arg_fail(2)) SWIG_fail;
35673 {
35674 PyThreadState* __tstate = wxPyBeginAllowThreads();
35675 (arg1)->Attach(arg2);
35676
35677 wxPyEndAllowThreads(__tstate);
35678 if (PyErr_Occurred()) SWIG_fail;
35679 }
35680 Py_INCREF(Py_None); resultobj = Py_None;
35681 return resultobj;
35682 fail:
35683 return NULL;
35684 }
35685
35686
35687 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35688 PyObject *resultobj;
35689 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35690 PyObject * obj0 = 0 ;
35691 char *kwnames[] = {
35692 (char *) "self", NULL
35693 };
35694
35695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35697 if (SWIG_arg_fail(1)) SWIG_fail;
35698 {
35699 PyThreadState* __tstate = wxPyBeginAllowThreads();
35700 (arg1)->Detach();
35701
35702 wxPyEndAllowThreads(__tstate);
35703 if (PyErr_Occurred()) SWIG_fail;
35704 }
35705 Py_INCREF(Py_None); resultobj = Py_None;
35706 return resultobj;
35707 fail:
35708 return NULL;
35709 }
35710
35711
35712 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35713 PyObject *obj;
35714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35715 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35716 Py_INCREF(obj);
35717 return Py_BuildValue((char *)"");
35718 }
35719 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35720 PyObject *resultobj;
35721 wxMenu *arg1 = (wxMenu *) NULL ;
35722 int arg2 = (int) wxID_ANY ;
35723 wxString const &arg3_defvalue = wxPyEmptyString ;
35724 wxString *arg3 = (wxString *) &arg3_defvalue ;
35725 wxString const &arg4_defvalue = wxPyEmptyString ;
35726 wxString *arg4 = (wxString *) &arg4_defvalue ;
35727 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35728 wxMenu *arg6 = (wxMenu *) NULL ;
35729 wxMenuItem *result;
35730 bool temp3 = false ;
35731 bool temp4 = false ;
35732 PyObject * obj0 = 0 ;
35733 PyObject * obj1 = 0 ;
35734 PyObject * obj2 = 0 ;
35735 PyObject * obj3 = 0 ;
35736 PyObject * obj4 = 0 ;
35737 PyObject * obj5 = 0 ;
35738 char *kwnames[] = {
35739 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35740 };
35741
35742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35743 if (obj0) {
35744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35745 if (SWIG_arg_fail(1)) SWIG_fail;
35746 }
35747 if (obj1) {
35748 {
35749 arg2 = (int)(SWIG_As_int(obj1));
35750 if (SWIG_arg_fail(2)) SWIG_fail;
35751 }
35752 }
35753 if (obj2) {
35754 {
35755 arg3 = wxString_in_helper(obj2);
35756 if (arg3 == NULL) SWIG_fail;
35757 temp3 = true;
35758 }
35759 }
35760 if (obj3) {
35761 {
35762 arg4 = wxString_in_helper(obj3);
35763 if (arg4 == NULL) SWIG_fail;
35764 temp4 = true;
35765 }
35766 }
35767 if (obj4) {
35768 {
35769 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35770 if (SWIG_arg_fail(5)) SWIG_fail;
35771 }
35772 }
35773 if (obj5) {
35774 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35775 if (SWIG_arg_fail(6)) SWIG_fail;
35776 }
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35780
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 {
35785 resultobj = wxPyMake_wxObject(result, 1);
35786 }
35787 {
35788 if (temp3)
35789 delete arg3;
35790 }
35791 {
35792 if (temp4)
35793 delete arg4;
35794 }
35795 return resultobj;
35796 fail:
35797 {
35798 if (temp3)
35799 delete arg3;
35800 }
35801 {
35802 if (temp4)
35803 delete arg4;
35804 }
35805 return NULL;
35806 }
35807
35808
35809 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35810 PyObject *resultobj;
35811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35812 wxMenu *result;
35813 PyObject * obj0 = 0 ;
35814 char *kwnames[] = {
35815 (char *) "self", NULL
35816 };
35817
35818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35820 if (SWIG_arg_fail(1)) SWIG_fail;
35821 {
35822 PyThreadState* __tstate = wxPyBeginAllowThreads();
35823 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35824
35825 wxPyEndAllowThreads(__tstate);
35826 if (PyErr_Occurred()) SWIG_fail;
35827 }
35828 {
35829 resultobj = wxPyMake_wxObject(result, 0);
35830 }
35831 return resultobj;
35832 fail:
35833 return NULL;
35834 }
35835
35836
35837 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35838 PyObject *resultobj;
35839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35840 wxMenu *arg2 = (wxMenu *) 0 ;
35841 PyObject * obj0 = 0 ;
35842 PyObject * obj1 = 0 ;
35843 char *kwnames[] = {
35844 (char *) "self",(char *) "menu", NULL
35845 };
35846
35847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35849 if (SWIG_arg_fail(1)) SWIG_fail;
35850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35851 if (SWIG_arg_fail(2)) SWIG_fail;
35852 {
35853 PyThreadState* __tstate = wxPyBeginAllowThreads();
35854 (arg1)->SetMenu(arg2);
35855
35856 wxPyEndAllowThreads(__tstate);
35857 if (PyErr_Occurred()) SWIG_fail;
35858 }
35859 Py_INCREF(Py_None); resultobj = Py_None;
35860 return resultobj;
35861 fail:
35862 return NULL;
35863 }
35864
35865
35866 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj;
35868 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35869 int arg2 ;
35870 PyObject * obj0 = 0 ;
35871 PyObject * obj1 = 0 ;
35872 char *kwnames[] = {
35873 (char *) "self",(char *) "id", NULL
35874 };
35875
35876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35878 if (SWIG_arg_fail(1)) SWIG_fail;
35879 {
35880 arg2 = (int)(SWIG_As_int(obj1));
35881 if (SWIG_arg_fail(2)) SWIG_fail;
35882 }
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 (arg1)->SetId(arg2);
35886
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 Py_INCREF(Py_None); resultobj = Py_None;
35891 return resultobj;
35892 fail:
35893 return NULL;
35894 }
35895
35896
35897 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35898 PyObject *resultobj;
35899 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35900 int result;
35901 PyObject * obj0 = 0 ;
35902 char *kwnames[] = {
35903 (char *) "self", NULL
35904 };
35905
35906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35908 if (SWIG_arg_fail(1)) SWIG_fail;
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 result = (int)((wxMenuItem const *)arg1)->GetId();
35912
35913 wxPyEndAllowThreads(__tstate);
35914 if (PyErr_Occurred()) SWIG_fail;
35915 }
35916 {
35917 resultobj = SWIG_From_int((int)(result));
35918 }
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj;
35927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35928 bool result;
35929 PyObject * obj0 = 0 ;
35930 char *kwnames[] = {
35931 (char *) "self", NULL
35932 };
35933
35934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35936 if (SWIG_arg_fail(1)) SWIG_fail;
35937 {
35938 PyThreadState* __tstate = wxPyBeginAllowThreads();
35939 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35940
35941 wxPyEndAllowThreads(__tstate);
35942 if (PyErr_Occurred()) SWIG_fail;
35943 }
35944 {
35945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35946 }
35947 return resultobj;
35948 fail:
35949 return NULL;
35950 }
35951
35952
35953 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35954 PyObject *resultobj;
35955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35956 wxString *arg2 = 0 ;
35957 bool temp2 = false ;
35958 PyObject * obj0 = 0 ;
35959 PyObject * obj1 = 0 ;
35960 char *kwnames[] = {
35961 (char *) "self",(char *) "str", NULL
35962 };
35963
35964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35966 if (SWIG_arg_fail(1)) SWIG_fail;
35967 {
35968 arg2 = wxString_in_helper(obj1);
35969 if (arg2 == NULL) SWIG_fail;
35970 temp2 = true;
35971 }
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 (arg1)->SetText((wxString const &)*arg2);
35975
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 Py_INCREF(Py_None); resultobj = Py_None;
35980 {
35981 if (temp2)
35982 delete arg2;
35983 }
35984 return resultobj;
35985 fail:
35986 {
35987 if (temp2)
35988 delete arg2;
35989 }
35990 return NULL;
35991 }
35992
35993
35994 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35995 PyObject *resultobj;
35996 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35997 wxString result;
35998 PyObject * obj0 = 0 ;
35999 char *kwnames[] = {
36000 (char *) "self", NULL
36001 };
36002
36003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36005 if (SWIG_arg_fail(1)) SWIG_fail;
36006 {
36007 PyThreadState* __tstate = wxPyBeginAllowThreads();
36008 result = ((wxMenuItem const *)arg1)->GetLabel();
36009
36010 wxPyEndAllowThreads(__tstate);
36011 if (PyErr_Occurred()) SWIG_fail;
36012 }
36013 {
36014 #if wxUSE_UNICODE
36015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36016 #else
36017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36018 #endif
36019 }
36020 return resultobj;
36021 fail:
36022 return NULL;
36023 }
36024
36025
36026 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36027 PyObject *resultobj;
36028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36029 wxString *result;
36030 PyObject * obj0 = 0 ;
36031 char *kwnames[] = {
36032 (char *) "self", NULL
36033 };
36034
36035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36037 if (SWIG_arg_fail(1)) SWIG_fail;
36038 {
36039 PyThreadState* __tstate = wxPyBeginAllowThreads();
36040 {
36041 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36042 result = (wxString *) &_result_ref;
36043 }
36044
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 {
36049 #if wxUSE_UNICODE
36050 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36051 #else
36052 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36053 #endif
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj;
36063 wxString *arg1 = 0 ;
36064 wxString result;
36065 bool temp1 = false ;
36066 PyObject * obj0 = 0 ;
36067 char *kwnames[] = {
36068 (char *) "text", NULL
36069 };
36070
36071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36072 {
36073 arg1 = wxString_in_helper(obj0);
36074 if (arg1 == NULL) SWIG_fail;
36075 temp1 = true;
36076 }
36077 {
36078 PyThreadState* __tstate = wxPyBeginAllowThreads();
36079 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36080
36081 wxPyEndAllowThreads(__tstate);
36082 if (PyErr_Occurred()) SWIG_fail;
36083 }
36084 {
36085 #if wxUSE_UNICODE
36086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36087 #else
36088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36089 #endif
36090 }
36091 {
36092 if (temp1)
36093 delete arg1;
36094 }
36095 return resultobj;
36096 fail:
36097 {
36098 if (temp1)
36099 delete arg1;
36100 }
36101 return NULL;
36102 }
36103
36104
36105 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36106 PyObject *resultobj;
36107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36108 wxItemKind result;
36109 PyObject * obj0 = 0 ;
36110 char *kwnames[] = {
36111 (char *) "self", NULL
36112 };
36113
36114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36116 if (SWIG_arg_fail(1)) SWIG_fail;
36117 {
36118 PyThreadState* __tstate = wxPyBeginAllowThreads();
36119 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36120
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 resultobj = SWIG_From_int((result));
36125 return resultobj;
36126 fail:
36127 return NULL;
36128 }
36129
36130
36131 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36132 PyObject *resultobj;
36133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36134 wxItemKind arg2 ;
36135 PyObject * obj0 = 0 ;
36136 PyObject * obj1 = 0 ;
36137 char *kwnames[] = {
36138 (char *) "self",(char *) "kind", NULL
36139 };
36140
36141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36143 if (SWIG_arg_fail(1)) SWIG_fail;
36144 {
36145 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36146 if (SWIG_arg_fail(2)) SWIG_fail;
36147 }
36148 {
36149 PyThreadState* __tstate = wxPyBeginAllowThreads();
36150 (arg1)->SetKind((wxItemKind )arg2);
36151
36152 wxPyEndAllowThreads(__tstate);
36153 if (PyErr_Occurred()) SWIG_fail;
36154 }
36155 Py_INCREF(Py_None); resultobj = Py_None;
36156 return resultobj;
36157 fail:
36158 return NULL;
36159 }
36160
36161
36162 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36163 PyObject *resultobj;
36164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36165 bool arg2 ;
36166 PyObject * obj0 = 0 ;
36167 PyObject * obj1 = 0 ;
36168 char *kwnames[] = {
36169 (char *) "self",(char *) "checkable", NULL
36170 };
36171
36172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36174 if (SWIG_arg_fail(1)) SWIG_fail;
36175 {
36176 arg2 = (bool)(SWIG_As_bool(obj1));
36177 if (SWIG_arg_fail(2)) SWIG_fail;
36178 }
36179 {
36180 PyThreadState* __tstate = wxPyBeginAllowThreads();
36181 (arg1)->SetCheckable(arg2);
36182
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 Py_INCREF(Py_None); resultobj = Py_None;
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36194 PyObject *resultobj;
36195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36196 bool result;
36197 PyObject * obj0 = 0 ;
36198 char *kwnames[] = {
36199 (char *) "self", NULL
36200 };
36201
36202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36204 if (SWIG_arg_fail(1)) SWIG_fail;
36205 {
36206 PyThreadState* __tstate = wxPyBeginAllowThreads();
36207 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36208
36209 wxPyEndAllowThreads(__tstate);
36210 if (PyErr_Occurred()) SWIG_fail;
36211 }
36212 {
36213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36214 }
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36222 PyObject *resultobj;
36223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36224 bool result;
36225 PyObject * obj0 = 0 ;
36226 char *kwnames[] = {
36227 (char *) "self", NULL
36228 };
36229
36230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36232 if (SWIG_arg_fail(1)) SWIG_fail;
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36236
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 {
36241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36242 }
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36250 PyObject *resultobj;
36251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36252 wxMenu *arg2 = (wxMenu *) 0 ;
36253 PyObject * obj0 = 0 ;
36254 PyObject * obj1 = 0 ;
36255 char *kwnames[] = {
36256 (char *) "self",(char *) "menu", NULL
36257 };
36258
36259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36261 if (SWIG_arg_fail(1)) SWIG_fail;
36262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36263 if (SWIG_arg_fail(2)) SWIG_fail;
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 (arg1)->SetSubMenu(arg2);
36267
36268 wxPyEndAllowThreads(__tstate);
36269 if (PyErr_Occurred()) SWIG_fail;
36270 }
36271 Py_INCREF(Py_None); resultobj = Py_None;
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36279 PyObject *resultobj;
36280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36281 wxMenu *result;
36282 PyObject * obj0 = 0 ;
36283 char *kwnames[] = {
36284 (char *) "self", NULL
36285 };
36286
36287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36289 if (SWIG_arg_fail(1)) SWIG_fail;
36290 {
36291 PyThreadState* __tstate = wxPyBeginAllowThreads();
36292 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36293
36294 wxPyEndAllowThreads(__tstate);
36295 if (PyErr_Occurred()) SWIG_fail;
36296 }
36297 {
36298 resultobj = wxPyMake_wxObject(result, 0);
36299 }
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36307 PyObject *resultobj;
36308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36309 bool arg2 = (bool) true ;
36310 PyObject * obj0 = 0 ;
36311 PyObject * obj1 = 0 ;
36312 char *kwnames[] = {
36313 (char *) "self",(char *) "enable", NULL
36314 };
36315
36316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36318 if (SWIG_arg_fail(1)) SWIG_fail;
36319 if (obj1) {
36320 {
36321 arg2 = (bool)(SWIG_As_bool(obj1));
36322 if (SWIG_arg_fail(2)) SWIG_fail;
36323 }
36324 }
36325 {
36326 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 (arg1)->Enable(arg2);
36328
36329 wxPyEndAllowThreads(__tstate);
36330 if (PyErr_Occurred()) SWIG_fail;
36331 }
36332 Py_INCREF(Py_None); resultobj = Py_None;
36333 return resultobj;
36334 fail:
36335 return NULL;
36336 }
36337
36338
36339 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36340 PyObject *resultobj;
36341 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36342 bool result;
36343 PyObject * obj0 = 0 ;
36344 char *kwnames[] = {
36345 (char *) "self", NULL
36346 };
36347
36348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36350 if (SWIG_arg_fail(1)) SWIG_fail;
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36354
36355 wxPyEndAllowThreads(__tstate);
36356 if (PyErr_Occurred()) SWIG_fail;
36357 }
36358 {
36359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36360 }
36361 return resultobj;
36362 fail:
36363 return NULL;
36364 }
36365
36366
36367 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36368 PyObject *resultobj;
36369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36370 bool arg2 = (bool) true ;
36371 PyObject * obj0 = 0 ;
36372 PyObject * obj1 = 0 ;
36373 char *kwnames[] = {
36374 (char *) "self",(char *) "check", NULL
36375 };
36376
36377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36379 if (SWIG_arg_fail(1)) SWIG_fail;
36380 if (obj1) {
36381 {
36382 arg2 = (bool)(SWIG_As_bool(obj1));
36383 if (SWIG_arg_fail(2)) SWIG_fail;
36384 }
36385 }
36386 {
36387 PyThreadState* __tstate = wxPyBeginAllowThreads();
36388 (arg1)->Check(arg2);
36389
36390 wxPyEndAllowThreads(__tstate);
36391 if (PyErr_Occurred()) SWIG_fail;
36392 }
36393 Py_INCREF(Py_None); resultobj = Py_None;
36394 return resultobj;
36395 fail:
36396 return NULL;
36397 }
36398
36399
36400 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36401 PyObject *resultobj;
36402 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36403 bool result;
36404 PyObject * obj0 = 0 ;
36405 char *kwnames[] = {
36406 (char *) "self", NULL
36407 };
36408
36409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36411 if (SWIG_arg_fail(1)) SWIG_fail;
36412 {
36413 PyThreadState* __tstate = wxPyBeginAllowThreads();
36414 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36415
36416 wxPyEndAllowThreads(__tstate);
36417 if (PyErr_Occurred()) SWIG_fail;
36418 }
36419 {
36420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36421 }
36422 return resultobj;
36423 fail:
36424 return NULL;
36425 }
36426
36427
36428 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36429 PyObject *resultobj;
36430 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36431 PyObject * obj0 = 0 ;
36432 char *kwnames[] = {
36433 (char *) "self", NULL
36434 };
36435
36436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36438 if (SWIG_arg_fail(1)) SWIG_fail;
36439 {
36440 PyThreadState* __tstate = wxPyBeginAllowThreads();
36441 (arg1)->Toggle();
36442
36443 wxPyEndAllowThreads(__tstate);
36444 if (PyErr_Occurred()) SWIG_fail;
36445 }
36446 Py_INCREF(Py_None); resultobj = Py_None;
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj;
36455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36456 wxString *arg2 = 0 ;
36457 bool temp2 = false ;
36458 PyObject * obj0 = 0 ;
36459 PyObject * obj1 = 0 ;
36460 char *kwnames[] = {
36461 (char *) "self",(char *) "str", NULL
36462 };
36463
36464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36466 if (SWIG_arg_fail(1)) SWIG_fail;
36467 {
36468 arg2 = wxString_in_helper(obj1);
36469 if (arg2 == NULL) SWIG_fail;
36470 temp2 = true;
36471 }
36472 {
36473 PyThreadState* __tstate = wxPyBeginAllowThreads();
36474 (arg1)->SetHelp((wxString const &)*arg2);
36475
36476 wxPyEndAllowThreads(__tstate);
36477 if (PyErr_Occurred()) SWIG_fail;
36478 }
36479 Py_INCREF(Py_None); resultobj = Py_None;
36480 {
36481 if (temp2)
36482 delete arg2;
36483 }
36484 return resultobj;
36485 fail:
36486 {
36487 if (temp2)
36488 delete arg2;
36489 }
36490 return NULL;
36491 }
36492
36493
36494 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36495 PyObject *resultobj;
36496 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36497 wxString *result;
36498 PyObject * obj0 = 0 ;
36499 char *kwnames[] = {
36500 (char *) "self", NULL
36501 };
36502
36503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36505 if (SWIG_arg_fail(1)) SWIG_fail;
36506 {
36507 PyThreadState* __tstate = wxPyBeginAllowThreads();
36508 {
36509 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36510 result = (wxString *) &_result_ref;
36511 }
36512
36513 wxPyEndAllowThreads(__tstate);
36514 if (PyErr_Occurred()) SWIG_fail;
36515 }
36516 {
36517 #if wxUSE_UNICODE
36518 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36519 #else
36520 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36521 #endif
36522 }
36523 return resultobj;
36524 fail:
36525 return NULL;
36526 }
36527
36528
36529 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36530 PyObject *resultobj;
36531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36532 wxAcceleratorEntry *result;
36533 PyObject * obj0 = 0 ;
36534 char *kwnames[] = {
36535 (char *) "self", NULL
36536 };
36537
36538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36540 if (SWIG_arg_fail(1)) SWIG_fail;
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36544
36545 wxPyEndAllowThreads(__tstate);
36546 if (PyErr_Occurred()) SWIG_fail;
36547 }
36548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36549 return resultobj;
36550 fail:
36551 return NULL;
36552 }
36553
36554
36555 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36556 PyObject *resultobj;
36557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36558 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36559 PyObject * obj0 = 0 ;
36560 PyObject * obj1 = 0 ;
36561 char *kwnames[] = {
36562 (char *) "self",(char *) "accel", NULL
36563 };
36564
36565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36567 if (SWIG_arg_fail(1)) SWIG_fail;
36568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36569 if (SWIG_arg_fail(2)) SWIG_fail;
36570 {
36571 PyThreadState* __tstate = wxPyBeginAllowThreads();
36572 (arg1)->SetAccel(arg2);
36573
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 Py_INCREF(Py_None); resultobj = Py_None;
36578 return resultobj;
36579 fail:
36580 return NULL;
36581 }
36582
36583
36584 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36585 PyObject *resultobj;
36586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36587 wxFont *arg2 = 0 ;
36588 PyObject * obj0 = 0 ;
36589 PyObject * obj1 = 0 ;
36590 char *kwnames[] = {
36591 (char *) "self",(char *) "font", NULL
36592 };
36593
36594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36596 if (SWIG_arg_fail(1)) SWIG_fail;
36597 {
36598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36599 if (SWIG_arg_fail(2)) SWIG_fail;
36600 if (arg2 == NULL) {
36601 SWIG_null_ref("wxFont");
36602 }
36603 if (SWIG_arg_fail(2)) SWIG_fail;
36604 }
36605 {
36606 PyThreadState* __tstate = wxPyBeginAllowThreads();
36607 (arg1)->SetFont((wxFont const &)*arg2);
36608
36609 wxPyEndAllowThreads(__tstate);
36610 if (PyErr_Occurred()) SWIG_fail;
36611 }
36612 Py_INCREF(Py_None); resultobj = Py_None;
36613 return resultobj;
36614 fail:
36615 return NULL;
36616 }
36617
36618
36619 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36620 PyObject *resultobj;
36621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36622 wxFont result;
36623 PyObject * obj0 = 0 ;
36624 char *kwnames[] = {
36625 (char *) "self", NULL
36626 };
36627
36628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36630 if (SWIG_arg_fail(1)) SWIG_fail;
36631 {
36632 PyThreadState* __tstate = wxPyBeginAllowThreads();
36633 result = (arg1)->GetFont();
36634
36635 wxPyEndAllowThreads(__tstate);
36636 if (PyErr_Occurred()) SWIG_fail;
36637 }
36638 {
36639 wxFont * resultptr;
36640 resultptr = new wxFont((wxFont &)(result));
36641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36642 }
36643 return resultobj;
36644 fail:
36645 return NULL;
36646 }
36647
36648
36649 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36650 PyObject *resultobj;
36651 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36652 wxColour *arg2 = 0 ;
36653 wxColour temp2 ;
36654 PyObject * obj0 = 0 ;
36655 PyObject * obj1 = 0 ;
36656 char *kwnames[] = {
36657 (char *) "self",(char *) "colText", NULL
36658 };
36659
36660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36662 if (SWIG_arg_fail(1)) SWIG_fail;
36663 {
36664 arg2 = &temp2;
36665 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36666 }
36667 {
36668 PyThreadState* __tstate = wxPyBeginAllowThreads();
36669 (arg1)->SetTextColour((wxColour const &)*arg2);
36670
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 Py_INCREF(Py_None); resultobj = Py_None;
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36682 PyObject *resultobj;
36683 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36684 wxColour result;
36685 PyObject * obj0 = 0 ;
36686 char *kwnames[] = {
36687 (char *) "self", NULL
36688 };
36689
36690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36692 if (SWIG_arg_fail(1)) SWIG_fail;
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 result = (arg1)->GetTextColour();
36696
36697 wxPyEndAllowThreads(__tstate);
36698 if (PyErr_Occurred()) SWIG_fail;
36699 }
36700 {
36701 wxColour * resultptr;
36702 resultptr = new wxColour((wxColour &)(result));
36703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36704 }
36705 return resultobj;
36706 fail:
36707 return NULL;
36708 }
36709
36710
36711 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36712 PyObject *resultobj;
36713 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36714 wxColour *arg2 = 0 ;
36715 wxColour temp2 ;
36716 PyObject * obj0 = 0 ;
36717 PyObject * obj1 = 0 ;
36718 char *kwnames[] = {
36719 (char *) "self",(char *) "colBack", NULL
36720 };
36721
36722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36724 if (SWIG_arg_fail(1)) SWIG_fail;
36725 {
36726 arg2 = &temp2;
36727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36728 }
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36732
36733 wxPyEndAllowThreads(__tstate);
36734 if (PyErr_Occurred()) SWIG_fail;
36735 }
36736 Py_INCREF(Py_None); resultobj = Py_None;
36737 return resultobj;
36738 fail:
36739 return NULL;
36740 }
36741
36742
36743 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36744 PyObject *resultobj;
36745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36746 wxColour result;
36747 PyObject * obj0 = 0 ;
36748 char *kwnames[] = {
36749 (char *) "self", NULL
36750 };
36751
36752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36754 if (SWIG_arg_fail(1)) SWIG_fail;
36755 {
36756 PyThreadState* __tstate = wxPyBeginAllowThreads();
36757 result = (arg1)->GetBackgroundColour();
36758
36759 wxPyEndAllowThreads(__tstate);
36760 if (PyErr_Occurred()) SWIG_fail;
36761 }
36762 {
36763 wxColour * resultptr;
36764 resultptr = new wxColour((wxColour &)(result));
36765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36766 }
36767 return resultobj;
36768 fail:
36769 return NULL;
36770 }
36771
36772
36773 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36774 PyObject *resultobj;
36775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36776 wxBitmap *arg2 = 0 ;
36777 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36778 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36779 PyObject * obj0 = 0 ;
36780 PyObject * obj1 = 0 ;
36781 PyObject * obj2 = 0 ;
36782 char *kwnames[] = {
36783 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36784 };
36785
36786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36788 if (SWIG_arg_fail(1)) SWIG_fail;
36789 {
36790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36791 if (SWIG_arg_fail(2)) SWIG_fail;
36792 if (arg2 == NULL) {
36793 SWIG_null_ref("wxBitmap");
36794 }
36795 if (SWIG_arg_fail(2)) SWIG_fail;
36796 }
36797 if (obj2) {
36798 {
36799 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36800 if (SWIG_arg_fail(3)) SWIG_fail;
36801 if (arg3 == NULL) {
36802 SWIG_null_ref("wxBitmap");
36803 }
36804 if (SWIG_arg_fail(3)) SWIG_fail;
36805 }
36806 }
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36810
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 Py_INCREF(Py_None); resultobj = Py_None;
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36822 PyObject *resultobj;
36823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36824 wxBitmap *arg2 = 0 ;
36825 PyObject * obj0 = 0 ;
36826 PyObject * obj1 = 0 ;
36827 char *kwnames[] = {
36828 (char *) "self",(char *) "bmpDisabled", NULL
36829 };
36830
36831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36833 if (SWIG_arg_fail(1)) SWIG_fail;
36834 {
36835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36836 if (SWIG_arg_fail(2)) SWIG_fail;
36837 if (arg2 == NULL) {
36838 SWIG_null_ref("wxBitmap");
36839 }
36840 if (SWIG_arg_fail(2)) SWIG_fail;
36841 }
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36845
36846 wxPyEndAllowThreads(__tstate);
36847 if (PyErr_Occurred()) SWIG_fail;
36848 }
36849 Py_INCREF(Py_None); resultobj = Py_None;
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36857 PyObject *resultobj;
36858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36859 wxBitmap *result;
36860 PyObject * obj0 = 0 ;
36861 char *kwnames[] = {
36862 (char *) "self", NULL
36863 };
36864
36865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36867 if (SWIG_arg_fail(1)) SWIG_fail;
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 {
36871 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36872 result = (wxBitmap *) &_result_ref;
36873 }
36874
36875 wxPyEndAllowThreads(__tstate);
36876 if (PyErr_Occurred()) SWIG_fail;
36877 }
36878 {
36879 wxBitmap* resultptr = new wxBitmap(*result);
36880 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36881 }
36882 return resultobj;
36883 fail:
36884 return NULL;
36885 }
36886
36887
36888 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36889 PyObject *resultobj;
36890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36891 int arg2 ;
36892 PyObject * obj0 = 0 ;
36893 PyObject * obj1 = 0 ;
36894 char *kwnames[] = {
36895 (char *) "self",(char *) "nWidth", NULL
36896 };
36897
36898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36900 if (SWIG_arg_fail(1)) SWIG_fail;
36901 {
36902 arg2 = (int)(SWIG_As_int(obj1));
36903 if (SWIG_arg_fail(2)) SWIG_fail;
36904 }
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 (arg1)->SetMarginWidth(arg2);
36908
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 Py_INCREF(Py_None); resultobj = Py_None;
36913 return resultobj;
36914 fail:
36915 return NULL;
36916 }
36917
36918
36919 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36920 PyObject *resultobj;
36921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36922 int result;
36923 PyObject * obj0 = 0 ;
36924 char *kwnames[] = {
36925 (char *) "self", NULL
36926 };
36927
36928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36930 if (SWIG_arg_fail(1)) SWIG_fail;
36931 {
36932 PyThreadState* __tstate = wxPyBeginAllowThreads();
36933 result = (int)(arg1)->GetMarginWidth();
36934
36935 wxPyEndAllowThreads(__tstate);
36936 if (PyErr_Occurred()) SWIG_fail;
36937 }
36938 {
36939 resultobj = SWIG_From_int((int)(result));
36940 }
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36948 PyObject *resultobj;
36949 int result;
36950 char *kwnames[] = {
36951 NULL
36952 };
36953
36954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36955 {
36956 PyThreadState* __tstate = wxPyBeginAllowThreads();
36957 result = (int)wxMenuItem::GetDefaultMarginWidth();
36958
36959 wxPyEndAllowThreads(__tstate);
36960 if (PyErr_Occurred()) SWIG_fail;
36961 }
36962 {
36963 resultobj = SWIG_From_int((int)(result));
36964 }
36965 return resultobj;
36966 fail:
36967 return NULL;
36968 }
36969
36970
36971 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36972 PyObject *resultobj;
36973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36974 bool result;
36975 PyObject * obj0 = 0 ;
36976 char *kwnames[] = {
36977 (char *) "self", NULL
36978 };
36979
36980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36982 if (SWIG_arg_fail(1)) SWIG_fail;
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 result = (bool)(arg1)->IsOwnerDrawn();
36986
36987 wxPyEndAllowThreads(__tstate);
36988 if (PyErr_Occurred()) SWIG_fail;
36989 }
36990 {
36991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36992 }
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37000 PyObject *resultobj;
37001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37002 bool arg2 = (bool) true ;
37003 PyObject * obj0 = 0 ;
37004 PyObject * obj1 = 0 ;
37005 char *kwnames[] = {
37006 (char *) "self",(char *) "ownerDrawn", NULL
37007 };
37008
37009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37011 if (SWIG_arg_fail(1)) SWIG_fail;
37012 if (obj1) {
37013 {
37014 arg2 = (bool)(SWIG_As_bool(obj1));
37015 if (SWIG_arg_fail(2)) SWIG_fail;
37016 }
37017 }
37018 {
37019 PyThreadState* __tstate = wxPyBeginAllowThreads();
37020 (arg1)->SetOwnerDrawn(arg2);
37021
37022 wxPyEndAllowThreads(__tstate);
37023 if (PyErr_Occurred()) SWIG_fail;
37024 }
37025 Py_INCREF(Py_None); resultobj = Py_None;
37026 return resultobj;
37027 fail:
37028 return NULL;
37029 }
37030
37031
37032 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37033 PyObject *resultobj;
37034 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37035 PyObject * obj0 = 0 ;
37036 char *kwnames[] = {
37037 (char *) "self", NULL
37038 };
37039
37040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37042 if (SWIG_arg_fail(1)) SWIG_fail;
37043 {
37044 PyThreadState* __tstate = wxPyBeginAllowThreads();
37045 (arg1)->ResetOwnerDrawn();
37046
37047 wxPyEndAllowThreads(__tstate);
37048 if (PyErr_Occurred()) SWIG_fail;
37049 }
37050 Py_INCREF(Py_None); resultobj = Py_None;
37051 return resultobj;
37052 fail:
37053 return NULL;
37054 }
37055
37056
37057 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37058 PyObject *resultobj;
37059 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37060 wxBitmap *arg2 = 0 ;
37061 PyObject * obj0 = 0 ;
37062 PyObject * obj1 = 0 ;
37063 char *kwnames[] = {
37064 (char *) "self",(char *) "bitmap", NULL
37065 };
37066
37067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37069 if (SWIG_arg_fail(1)) SWIG_fail;
37070 {
37071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37072 if (SWIG_arg_fail(2)) SWIG_fail;
37073 if (arg2 == NULL) {
37074 SWIG_null_ref("wxBitmap");
37075 }
37076 if (SWIG_arg_fail(2)) SWIG_fail;
37077 }
37078 {
37079 PyThreadState* __tstate = wxPyBeginAllowThreads();
37080 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37081
37082 wxPyEndAllowThreads(__tstate);
37083 if (PyErr_Occurred()) SWIG_fail;
37084 }
37085 Py_INCREF(Py_None); resultobj = Py_None;
37086 return resultobj;
37087 fail:
37088 return NULL;
37089 }
37090
37091
37092 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37093 PyObject *resultobj;
37094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37095 wxBitmap *result;
37096 PyObject * obj0 = 0 ;
37097 char *kwnames[] = {
37098 (char *) "self", NULL
37099 };
37100
37101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37103 if (SWIG_arg_fail(1)) SWIG_fail;
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 {
37107 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37108 result = (wxBitmap *) &_result_ref;
37109 }
37110
37111 wxPyEndAllowThreads(__tstate);
37112 if (PyErr_Occurred()) SWIG_fail;
37113 }
37114 {
37115 wxBitmap* resultptr = new wxBitmap(*result);
37116 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37117 }
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37125 PyObject *obj;
37126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37127 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37128 Py_INCREF(obj);
37129 return Py_BuildValue((char *)"");
37130 }
37131 static int _wrap_ControlNameStr_set(PyObject *) {
37132 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37133 return 1;
37134 }
37135
37136
37137 static PyObject *_wrap_ControlNameStr_get(void) {
37138 PyObject *pyobj;
37139
37140 {
37141 #if wxUSE_UNICODE
37142 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37143 #else
37144 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37145 #endif
37146 }
37147 return pyobj;
37148 }
37149
37150
37151 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37152 PyObject *resultobj;
37153 wxWindow *arg1 = (wxWindow *) 0 ;
37154 int arg2 = (int) -1 ;
37155 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37156 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37157 wxSize const &arg4_defvalue = wxDefaultSize ;
37158 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37159 long arg5 = (long) 0 ;
37160 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37161 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37162 wxString const &arg7_defvalue = wxPyControlNameStr ;
37163 wxString *arg7 = (wxString *) &arg7_defvalue ;
37164 wxControl *result;
37165 wxPoint temp3 ;
37166 wxSize temp4 ;
37167 bool temp7 = false ;
37168 PyObject * obj0 = 0 ;
37169 PyObject * obj1 = 0 ;
37170 PyObject * obj2 = 0 ;
37171 PyObject * obj3 = 0 ;
37172 PyObject * obj4 = 0 ;
37173 PyObject * obj5 = 0 ;
37174 PyObject * obj6 = 0 ;
37175 char *kwnames[] = {
37176 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37177 };
37178
37179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37181 if (SWIG_arg_fail(1)) SWIG_fail;
37182 if (obj1) {
37183 {
37184 arg2 = (int)(SWIG_As_int(obj1));
37185 if (SWIG_arg_fail(2)) SWIG_fail;
37186 }
37187 }
37188 if (obj2) {
37189 {
37190 arg3 = &temp3;
37191 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37192 }
37193 }
37194 if (obj3) {
37195 {
37196 arg4 = &temp4;
37197 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37198 }
37199 }
37200 if (obj4) {
37201 {
37202 arg5 = (long)(SWIG_As_long(obj4));
37203 if (SWIG_arg_fail(5)) SWIG_fail;
37204 }
37205 }
37206 if (obj5) {
37207 {
37208 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37209 if (SWIG_arg_fail(6)) SWIG_fail;
37210 if (arg6 == NULL) {
37211 SWIG_null_ref("wxValidator");
37212 }
37213 if (SWIG_arg_fail(6)) SWIG_fail;
37214 }
37215 }
37216 if (obj6) {
37217 {
37218 arg7 = wxString_in_helper(obj6);
37219 if (arg7 == NULL) SWIG_fail;
37220 temp7 = true;
37221 }
37222 }
37223 {
37224 if (!wxPyCheckForApp()) SWIG_fail;
37225 PyThreadState* __tstate = wxPyBeginAllowThreads();
37226 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37227
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37232 {
37233 if (temp7)
37234 delete arg7;
37235 }
37236 return resultobj;
37237 fail:
37238 {
37239 if (temp7)
37240 delete arg7;
37241 }
37242 return NULL;
37243 }
37244
37245
37246 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj;
37248 wxControl *result;
37249 char *kwnames[] = {
37250 NULL
37251 };
37252
37253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37254 {
37255 if (!wxPyCheckForApp()) SWIG_fail;
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = (wxControl *)new wxControl();
37258
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37263 return resultobj;
37264 fail:
37265 return NULL;
37266 }
37267
37268
37269 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37270 PyObject *resultobj;
37271 wxControl *arg1 = (wxControl *) 0 ;
37272 wxWindow *arg2 = (wxWindow *) 0 ;
37273 int arg3 = (int) -1 ;
37274 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37275 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37276 wxSize const &arg5_defvalue = wxDefaultSize ;
37277 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37278 long arg6 = (long) 0 ;
37279 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37280 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37281 wxString const &arg8_defvalue = wxPyControlNameStr ;
37282 wxString *arg8 = (wxString *) &arg8_defvalue ;
37283 bool result;
37284 wxPoint temp4 ;
37285 wxSize temp5 ;
37286 bool temp8 = false ;
37287 PyObject * obj0 = 0 ;
37288 PyObject * obj1 = 0 ;
37289 PyObject * obj2 = 0 ;
37290 PyObject * obj3 = 0 ;
37291 PyObject * obj4 = 0 ;
37292 PyObject * obj5 = 0 ;
37293 PyObject * obj6 = 0 ;
37294 PyObject * obj7 = 0 ;
37295 char *kwnames[] = {
37296 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37297 };
37298
37299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37301 if (SWIG_arg_fail(1)) SWIG_fail;
37302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37303 if (SWIG_arg_fail(2)) SWIG_fail;
37304 if (obj2) {
37305 {
37306 arg3 = (int)(SWIG_As_int(obj2));
37307 if (SWIG_arg_fail(3)) SWIG_fail;
37308 }
37309 }
37310 if (obj3) {
37311 {
37312 arg4 = &temp4;
37313 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37314 }
37315 }
37316 if (obj4) {
37317 {
37318 arg5 = &temp5;
37319 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37320 }
37321 }
37322 if (obj5) {
37323 {
37324 arg6 = (long)(SWIG_As_long(obj5));
37325 if (SWIG_arg_fail(6)) SWIG_fail;
37326 }
37327 }
37328 if (obj6) {
37329 {
37330 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37331 if (SWIG_arg_fail(7)) SWIG_fail;
37332 if (arg7 == NULL) {
37333 SWIG_null_ref("wxValidator");
37334 }
37335 if (SWIG_arg_fail(7)) SWIG_fail;
37336 }
37337 }
37338 if (obj7) {
37339 {
37340 arg8 = wxString_in_helper(obj7);
37341 if (arg8 == NULL) SWIG_fail;
37342 temp8 = true;
37343 }
37344 }
37345 {
37346 PyThreadState* __tstate = wxPyBeginAllowThreads();
37347 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37348
37349 wxPyEndAllowThreads(__tstate);
37350 if (PyErr_Occurred()) SWIG_fail;
37351 }
37352 {
37353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37354 }
37355 {
37356 if (temp8)
37357 delete arg8;
37358 }
37359 return resultobj;
37360 fail:
37361 {
37362 if (temp8)
37363 delete arg8;
37364 }
37365 return NULL;
37366 }
37367
37368
37369 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj;
37371 wxControl *arg1 = (wxControl *) 0 ;
37372 wxCommandEvent *arg2 = 0 ;
37373 PyObject * obj0 = 0 ;
37374 PyObject * obj1 = 0 ;
37375 char *kwnames[] = {
37376 (char *) "self",(char *) "event", NULL
37377 };
37378
37379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37381 if (SWIG_arg_fail(1)) SWIG_fail;
37382 {
37383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37384 if (SWIG_arg_fail(2)) SWIG_fail;
37385 if (arg2 == NULL) {
37386 SWIG_null_ref("wxCommandEvent");
37387 }
37388 if (SWIG_arg_fail(2)) SWIG_fail;
37389 }
37390 {
37391 PyThreadState* __tstate = wxPyBeginAllowThreads();
37392 (arg1)->Command(*arg2);
37393
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 Py_INCREF(Py_None); resultobj = Py_None;
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37405 PyObject *resultobj;
37406 wxControl *arg1 = (wxControl *) 0 ;
37407 wxString result;
37408 PyObject * obj0 = 0 ;
37409 char *kwnames[] = {
37410 (char *) "self", NULL
37411 };
37412
37413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37415 if (SWIG_arg_fail(1)) SWIG_fail;
37416 {
37417 PyThreadState* __tstate = wxPyBeginAllowThreads();
37418 result = (arg1)->GetLabel();
37419
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 {
37424 #if wxUSE_UNICODE
37425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37426 #else
37427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37428 #endif
37429 }
37430 return resultobj;
37431 fail:
37432 return NULL;
37433 }
37434
37435
37436 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37437 PyObject *resultobj;
37438 wxControl *arg1 = (wxControl *) 0 ;
37439 wxString *arg2 = 0 ;
37440 bool temp2 = false ;
37441 PyObject * obj0 = 0 ;
37442 PyObject * obj1 = 0 ;
37443 char *kwnames[] = {
37444 (char *) "self",(char *) "label", NULL
37445 };
37446
37447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37449 if (SWIG_arg_fail(1)) SWIG_fail;
37450 {
37451 arg2 = wxString_in_helper(obj1);
37452 if (arg2 == NULL) SWIG_fail;
37453 temp2 = true;
37454 }
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 (arg1)->SetLabel((wxString const &)*arg2);
37458
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 Py_INCREF(Py_None); resultobj = Py_None;
37463 {
37464 if (temp2)
37465 delete arg2;
37466 }
37467 return resultobj;
37468 fail:
37469 {
37470 if (temp2)
37471 delete arg2;
37472 }
37473 return NULL;
37474 }
37475
37476
37477 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37478 PyObject *resultobj;
37479 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37480 wxVisualAttributes result;
37481 PyObject * obj0 = 0 ;
37482 char *kwnames[] = {
37483 (char *) "variant", NULL
37484 };
37485
37486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37487 if (obj0) {
37488 {
37489 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37490 if (SWIG_arg_fail(1)) SWIG_fail;
37491 }
37492 }
37493 {
37494 if (!wxPyCheckForApp()) SWIG_fail;
37495 PyThreadState* __tstate = wxPyBeginAllowThreads();
37496 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37497
37498 wxPyEndAllowThreads(__tstate);
37499 if (PyErr_Occurred()) SWIG_fail;
37500 }
37501 {
37502 wxVisualAttributes * resultptr;
37503 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37505 }
37506 return resultobj;
37507 fail:
37508 return NULL;
37509 }
37510
37511
37512 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37513 PyObject *obj;
37514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37515 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37516 Py_INCREF(obj);
37517 return Py_BuildValue((char *)"");
37518 }
37519 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37520 PyObject *resultobj;
37521 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37522 wxString *arg2 = 0 ;
37523 PyObject *arg3 = (PyObject *) NULL ;
37524 int result;
37525 bool temp2 = false ;
37526 PyObject * obj0 = 0 ;
37527 PyObject * obj1 = 0 ;
37528 PyObject * obj2 = 0 ;
37529 char *kwnames[] = {
37530 (char *) "self",(char *) "item",(char *) "clientData", NULL
37531 };
37532
37533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37535 if (SWIG_arg_fail(1)) SWIG_fail;
37536 {
37537 arg2 = wxString_in_helper(obj1);
37538 if (arg2 == NULL) SWIG_fail;
37539 temp2 = true;
37540 }
37541 if (obj2) {
37542 arg3 = obj2;
37543 }
37544 {
37545 PyThreadState* __tstate = wxPyBeginAllowThreads();
37546 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37547
37548 wxPyEndAllowThreads(__tstate);
37549 if (PyErr_Occurred()) SWIG_fail;
37550 }
37551 {
37552 resultobj = SWIG_From_int((int)(result));
37553 }
37554 {
37555 if (temp2)
37556 delete arg2;
37557 }
37558 return resultobj;
37559 fail:
37560 {
37561 if (temp2)
37562 delete arg2;
37563 }
37564 return NULL;
37565 }
37566
37567
37568 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj;
37570 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37571 wxArrayString *arg2 = 0 ;
37572 bool temp2 = false ;
37573 PyObject * obj0 = 0 ;
37574 PyObject * obj1 = 0 ;
37575 char *kwnames[] = {
37576 (char *) "self",(char *) "strings", NULL
37577 };
37578
37579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37581 if (SWIG_arg_fail(1)) SWIG_fail;
37582 {
37583 if (! PySequence_Check(obj1)) {
37584 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37585 SWIG_fail;
37586 }
37587 arg2 = new wxArrayString;
37588 temp2 = true;
37589 int i, len=PySequence_Length(obj1);
37590 for (i=0; i<len; i++) {
37591 PyObject* item = PySequence_GetItem(obj1, i);
37592 #if wxUSE_UNICODE
37593 PyObject* str = PyObject_Unicode(item);
37594 #else
37595 PyObject* str = PyObject_Str(item);
37596 #endif
37597 if (PyErr_Occurred()) SWIG_fail;
37598 arg2->Add(Py2wxString(str));
37599 Py_DECREF(item);
37600 Py_DECREF(str);
37601 }
37602 }
37603 {
37604 PyThreadState* __tstate = wxPyBeginAllowThreads();
37605 (arg1)->Append((wxArrayString const &)*arg2);
37606
37607 wxPyEndAllowThreads(__tstate);
37608 if (PyErr_Occurred()) SWIG_fail;
37609 }
37610 Py_INCREF(Py_None); resultobj = Py_None;
37611 {
37612 if (temp2) delete arg2;
37613 }
37614 return resultobj;
37615 fail:
37616 {
37617 if (temp2) delete arg2;
37618 }
37619 return NULL;
37620 }
37621
37622
37623 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37624 PyObject *resultobj;
37625 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37626 wxString *arg2 = 0 ;
37627 int arg3 ;
37628 PyObject *arg4 = (PyObject *) NULL ;
37629 int result;
37630 bool temp2 = false ;
37631 PyObject * obj0 = 0 ;
37632 PyObject * obj1 = 0 ;
37633 PyObject * obj2 = 0 ;
37634 PyObject * obj3 = 0 ;
37635 char *kwnames[] = {
37636 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37637 };
37638
37639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37641 if (SWIG_arg_fail(1)) SWIG_fail;
37642 {
37643 arg2 = wxString_in_helper(obj1);
37644 if (arg2 == NULL) SWIG_fail;
37645 temp2 = true;
37646 }
37647 {
37648 arg3 = (int)(SWIG_As_int(obj2));
37649 if (SWIG_arg_fail(3)) SWIG_fail;
37650 }
37651 if (obj3) {
37652 arg4 = obj3;
37653 }
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37657
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 {
37662 resultobj = SWIG_From_int((int)(result));
37663 }
37664 {
37665 if (temp2)
37666 delete arg2;
37667 }
37668 return resultobj;
37669 fail:
37670 {
37671 if (temp2)
37672 delete arg2;
37673 }
37674 return NULL;
37675 }
37676
37677
37678 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj;
37680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37681 PyObject * obj0 = 0 ;
37682 char *kwnames[] = {
37683 (char *) "self", NULL
37684 };
37685
37686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37688 if (SWIG_arg_fail(1)) SWIG_fail;
37689 {
37690 PyThreadState* __tstate = wxPyBeginAllowThreads();
37691 (arg1)->Clear();
37692
37693 wxPyEndAllowThreads(__tstate);
37694 if (PyErr_Occurred()) SWIG_fail;
37695 }
37696 Py_INCREF(Py_None); resultobj = Py_None;
37697 return resultobj;
37698 fail:
37699 return NULL;
37700 }
37701
37702
37703 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37704 PyObject *resultobj;
37705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37706 int arg2 ;
37707 PyObject * obj0 = 0 ;
37708 PyObject * obj1 = 0 ;
37709 char *kwnames[] = {
37710 (char *) "self",(char *) "n", NULL
37711 };
37712
37713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37715 if (SWIG_arg_fail(1)) SWIG_fail;
37716 {
37717 arg2 = (int)(SWIG_As_int(obj1));
37718 if (SWIG_arg_fail(2)) SWIG_fail;
37719 }
37720 {
37721 PyThreadState* __tstate = wxPyBeginAllowThreads();
37722 (arg1)->Delete(arg2);
37723
37724 wxPyEndAllowThreads(__tstate);
37725 if (PyErr_Occurred()) SWIG_fail;
37726 }
37727 Py_INCREF(Py_None); resultobj = Py_None;
37728 return resultobj;
37729 fail:
37730 return NULL;
37731 }
37732
37733
37734 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37735 PyObject *resultobj;
37736 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37737 int arg2 ;
37738 PyObject *result;
37739 PyObject * obj0 = 0 ;
37740 PyObject * obj1 = 0 ;
37741 char *kwnames[] = {
37742 (char *) "self",(char *) "n", NULL
37743 };
37744
37745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37747 if (SWIG_arg_fail(1)) SWIG_fail;
37748 {
37749 arg2 = (int)(SWIG_As_int(obj1));
37750 if (SWIG_arg_fail(2)) SWIG_fail;
37751 }
37752 {
37753 PyThreadState* __tstate = wxPyBeginAllowThreads();
37754 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37755
37756 wxPyEndAllowThreads(__tstate);
37757 if (PyErr_Occurred()) SWIG_fail;
37758 }
37759 resultobj = result;
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj;
37768 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37769 int arg2 ;
37770 PyObject *arg3 = (PyObject *) 0 ;
37771 PyObject * obj0 = 0 ;
37772 PyObject * obj1 = 0 ;
37773 PyObject * obj2 = 0 ;
37774 char *kwnames[] = {
37775 (char *) "self",(char *) "n",(char *) "clientData", NULL
37776 };
37777
37778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37780 if (SWIG_arg_fail(1)) SWIG_fail;
37781 {
37782 arg2 = (int)(SWIG_As_int(obj1));
37783 if (SWIG_arg_fail(2)) SWIG_fail;
37784 }
37785 arg3 = obj2;
37786 {
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 wxItemContainer_SetClientData(arg1,arg2,arg3);
37789
37790 wxPyEndAllowThreads(__tstate);
37791 if (PyErr_Occurred()) SWIG_fail;
37792 }
37793 Py_INCREF(Py_None); resultobj = Py_None;
37794 return resultobj;
37795 fail:
37796 return NULL;
37797 }
37798
37799
37800 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37801 PyObject *resultobj;
37802 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37803 int result;
37804 PyObject * obj0 = 0 ;
37805 char *kwnames[] = {
37806 (char *) "self", NULL
37807 };
37808
37809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37811 if (SWIG_arg_fail(1)) SWIG_fail;
37812 {
37813 PyThreadState* __tstate = wxPyBeginAllowThreads();
37814 result = (int)((wxItemContainer const *)arg1)->GetCount();
37815
37816 wxPyEndAllowThreads(__tstate);
37817 if (PyErr_Occurred()) SWIG_fail;
37818 }
37819 {
37820 resultobj = SWIG_From_int((int)(result));
37821 }
37822 return resultobj;
37823 fail:
37824 return NULL;
37825 }
37826
37827
37828 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37829 PyObject *resultobj;
37830 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37831 bool result;
37832 PyObject * obj0 = 0 ;
37833 char *kwnames[] = {
37834 (char *) "self", NULL
37835 };
37836
37837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37839 if (SWIG_arg_fail(1)) SWIG_fail;
37840 {
37841 PyThreadState* __tstate = wxPyBeginAllowThreads();
37842 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37843
37844 wxPyEndAllowThreads(__tstate);
37845 if (PyErr_Occurred()) SWIG_fail;
37846 }
37847 {
37848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37849 }
37850 return resultobj;
37851 fail:
37852 return NULL;
37853 }
37854
37855
37856 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37857 PyObject *resultobj;
37858 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37859 int arg2 ;
37860 wxString result;
37861 PyObject * obj0 = 0 ;
37862 PyObject * obj1 = 0 ;
37863 char *kwnames[] = {
37864 (char *) "self",(char *) "n", NULL
37865 };
37866
37867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37869 if (SWIG_arg_fail(1)) SWIG_fail;
37870 {
37871 arg2 = (int)(SWIG_As_int(obj1));
37872 if (SWIG_arg_fail(2)) SWIG_fail;
37873 }
37874 {
37875 PyThreadState* __tstate = wxPyBeginAllowThreads();
37876 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37877
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 #if wxUSE_UNICODE
37883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37884 #else
37885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37886 #endif
37887 }
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37895 PyObject *resultobj;
37896 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37897 wxArrayString result;
37898 PyObject * obj0 = 0 ;
37899 char *kwnames[] = {
37900 (char *) "self", NULL
37901 };
37902
37903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37905 if (SWIG_arg_fail(1)) SWIG_fail;
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 result = ((wxItemContainer const *)arg1)->GetStrings();
37909
37910 wxPyEndAllowThreads(__tstate);
37911 if (PyErr_Occurred()) SWIG_fail;
37912 }
37913 {
37914 resultobj = wxArrayString2PyList_helper(result);
37915 }
37916 return resultobj;
37917 fail:
37918 return NULL;
37919 }
37920
37921
37922 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37923 PyObject *resultobj;
37924 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37925 int arg2 ;
37926 wxString *arg3 = 0 ;
37927 bool temp3 = false ;
37928 PyObject * obj0 = 0 ;
37929 PyObject * obj1 = 0 ;
37930 PyObject * obj2 = 0 ;
37931 char *kwnames[] = {
37932 (char *) "self",(char *) "n",(char *) "s", NULL
37933 };
37934
37935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37937 if (SWIG_arg_fail(1)) SWIG_fail;
37938 {
37939 arg2 = (int)(SWIG_As_int(obj1));
37940 if (SWIG_arg_fail(2)) SWIG_fail;
37941 }
37942 {
37943 arg3 = wxString_in_helper(obj2);
37944 if (arg3 == NULL) SWIG_fail;
37945 temp3 = true;
37946 }
37947 {
37948 PyThreadState* __tstate = wxPyBeginAllowThreads();
37949 (arg1)->SetString(arg2,(wxString const &)*arg3);
37950
37951 wxPyEndAllowThreads(__tstate);
37952 if (PyErr_Occurred()) SWIG_fail;
37953 }
37954 Py_INCREF(Py_None); resultobj = Py_None;
37955 {
37956 if (temp3)
37957 delete arg3;
37958 }
37959 return resultobj;
37960 fail:
37961 {
37962 if (temp3)
37963 delete arg3;
37964 }
37965 return NULL;
37966 }
37967
37968
37969 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37970 PyObject *resultobj;
37971 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37972 wxString *arg2 = 0 ;
37973 int result;
37974 bool temp2 = false ;
37975 PyObject * obj0 = 0 ;
37976 PyObject * obj1 = 0 ;
37977 char *kwnames[] = {
37978 (char *) "self",(char *) "s", NULL
37979 };
37980
37981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37983 if (SWIG_arg_fail(1)) SWIG_fail;
37984 {
37985 arg2 = wxString_in_helper(obj1);
37986 if (arg2 == NULL) SWIG_fail;
37987 temp2 = true;
37988 }
37989 {
37990 PyThreadState* __tstate = wxPyBeginAllowThreads();
37991 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37992
37993 wxPyEndAllowThreads(__tstate);
37994 if (PyErr_Occurred()) SWIG_fail;
37995 }
37996 {
37997 resultobj = SWIG_From_int((int)(result));
37998 }
37999 {
38000 if (temp2)
38001 delete arg2;
38002 }
38003 return resultobj;
38004 fail:
38005 {
38006 if (temp2)
38007 delete arg2;
38008 }
38009 return NULL;
38010 }
38011
38012
38013 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38014 PyObject *resultobj;
38015 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38016 int arg2 ;
38017 PyObject * obj0 = 0 ;
38018 PyObject * obj1 = 0 ;
38019 char *kwnames[] = {
38020 (char *) "self",(char *) "n", NULL
38021 };
38022
38023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38025 if (SWIG_arg_fail(1)) SWIG_fail;
38026 {
38027 arg2 = (int)(SWIG_As_int(obj1));
38028 if (SWIG_arg_fail(2)) SWIG_fail;
38029 }
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 (arg1)->SetSelection(arg2);
38033
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 Py_INCREF(Py_None); resultobj = Py_None;
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38045 PyObject *resultobj;
38046 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38047 int result;
38048 PyObject * obj0 = 0 ;
38049 char *kwnames[] = {
38050 (char *) "self", NULL
38051 };
38052
38053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38055 if (SWIG_arg_fail(1)) SWIG_fail;
38056 {
38057 PyThreadState* __tstate = wxPyBeginAllowThreads();
38058 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38059
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 resultobj = SWIG_From_int((int)(result));
38065 }
38066 return resultobj;
38067 fail:
38068 return NULL;
38069 }
38070
38071
38072 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38073 PyObject *resultobj;
38074 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38075 wxString *arg2 = 0 ;
38076 bool result;
38077 bool temp2 = false ;
38078 PyObject * obj0 = 0 ;
38079 PyObject * obj1 = 0 ;
38080 char *kwnames[] = {
38081 (char *) "self",(char *) "s", NULL
38082 };
38083
38084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38086 if (SWIG_arg_fail(1)) SWIG_fail;
38087 {
38088 arg2 = wxString_in_helper(obj1);
38089 if (arg2 == NULL) SWIG_fail;
38090 temp2 = true;
38091 }
38092 {
38093 PyThreadState* __tstate = wxPyBeginAllowThreads();
38094 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38095
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 {
38100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38101 }
38102 {
38103 if (temp2)
38104 delete arg2;
38105 }
38106 return resultobj;
38107 fail:
38108 {
38109 if (temp2)
38110 delete arg2;
38111 }
38112 return NULL;
38113 }
38114
38115
38116 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38117 PyObject *resultobj;
38118 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38119 wxString result;
38120 PyObject * obj0 = 0 ;
38121 char *kwnames[] = {
38122 (char *) "self", NULL
38123 };
38124
38125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38127 if (SWIG_arg_fail(1)) SWIG_fail;
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38131
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 {
38136 #if wxUSE_UNICODE
38137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38138 #else
38139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38140 #endif
38141 }
38142 return resultobj;
38143 fail:
38144 return NULL;
38145 }
38146
38147
38148 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38149 PyObject *resultobj;
38150 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38151 int arg2 ;
38152 PyObject * obj0 = 0 ;
38153 PyObject * obj1 = 0 ;
38154 char *kwnames[] = {
38155 (char *) "self",(char *) "n", NULL
38156 };
38157
38158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38160 if (SWIG_arg_fail(1)) SWIG_fail;
38161 {
38162 arg2 = (int)(SWIG_As_int(obj1));
38163 if (SWIG_arg_fail(2)) SWIG_fail;
38164 }
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 (arg1)->Select(arg2);
38168
38169 wxPyEndAllowThreads(__tstate);
38170 if (PyErr_Occurred()) SWIG_fail;
38171 }
38172 Py_INCREF(Py_None); resultobj = Py_None;
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38180 PyObject *obj;
38181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38182 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38183 Py_INCREF(obj);
38184 return Py_BuildValue((char *)"");
38185 }
38186 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38187 PyObject *obj;
38188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38189 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38190 Py_INCREF(obj);
38191 return Py_BuildValue((char *)"");
38192 }
38193 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38194 PyObject *resultobj;
38195 wxSizerItem *result;
38196 char *kwnames[] = {
38197 NULL
38198 };
38199
38200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38201 {
38202 PyThreadState* __tstate = wxPyBeginAllowThreads();
38203 result = (wxSizerItem *)new wxSizerItem();
38204
38205 wxPyEndAllowThreads(__tstate);
38206 if (PyErr_Occurred()) SWIG_fail;
38207 }
38208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj;
38217 wxWindow *arg1 = (wxWindow *) 0 ;
38218 int arg2 ;
38219 int arg3 ;
38220 int arg4 ;
38221 PyObject *arg5 = (PyObject *) NULL ;
38222 wxSizerItem *result;
38223 PyObject * obj0 = 0 ;
38224 PyObject * obj1 = 0 ;
38225 PyObject * obj2 = 0 ;
38226 PyObject * obj3 = 0 ;
38227 PyObject * obj4 = 0 ;
38228 char *kwnames[] = {
38229 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38230 };
38231
38232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38234 if (SWIG_arg_fail(1)) SWIG_fail;
38235 {
38236 arg2 = (int)(SWIG_As_int(obj1));
38237 if (SWIG_arg_fail(2)) SWIG_fail;
38238 }
38239 {
38240 arg3 = (int)(SWIG_As_int(obj2));
38241 if (SWIG_arg_fail(3)) SWIG_fail;
38242 }
38243 {
38244 arg4 = (int)(SWIG_As_int(obj3));
38245 if (SWIG_arg_fail(4)) SWIG_fail;
38246 }
38247 if (obj4) {
38248 arg5 = obj4;
38249 }
38250 {
38251 PyThreadState* __tstate = wxPyBeginAllowThreads();
38252 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38253
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38258 return resultobj;
38259 fail:
38260 return NULL;
38261 }
38262
38263
38264 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38265 PyObject *resultobj;
38266 int arg1 ;
38267 int arg2 ;
38268 int arg3 ;
38269 int arg4 ;
38270 int arg5 ;
38271 PyObject *arg6 = (PyObject *) NULL ;
38272 wxSizerItem *result;
38273 PyObject * obj0 = 0 ;
38274 PyObject * obj1 = 0 ;
38275 PyObject * obj2 = 0 ;
38276 PyObject * obj3 = 0 ;
38277 PyObject * obj4 = 0 ;
38278 PyObject * obj5 = 0 ;
38279 char *kwnames[] = {
38280 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38281 };
38282
38283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38284 {
38285 arg1 = (int)(SWIG_As_int(obj0));
38286 if (SWIG_arg_fail(1)) SWIG_fail;
38287 }
38288 {
38289 arg2 = (int)(SWIG_As_int(obj1));
38290 if (SWIG_arg_fail(2)) SWIG_fail;
38291 }
38292 {
38293 arg3 = (int)(SWIG_As_int(obj2));
38294 if (SWIG_arg_fail(3)) SWIG_fail;
38295 }
38296 {
38297 arg4 = (int)(SWIG_As_int(obj3));
38298 if (SWIG_arg_fail(4)) SWIG_fail;
38299 }
38300 {
38301 arg5 = (int)(SWIG_As_int(obj4));
38302 if (SWIG_arg_fail(5)) SWIG_fail;
38303 }
38304 if (obj5) {
38305 arg6 = obj5;
38306 }
38307 {
38308 PyThreadState* __tstate = wxPyBeginAllowThreads();
38309 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38310
38311 wxPyEndAllowThreads(__tstate);
38312 if (PyErr_Occurred()) SWIG_fail;
38313 }
38314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38315 return resultobj;
38316 fail:
38317 return NULL;
38318 }
38319
38320
38321 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38322 PyObject *resultobj;
38323 wxSizer *arg1 = (wxSizer *) 0 ;
38324 int arg2 ;
38325 int arg3 ;
38326 int arg4 ;
38327 PyObject *arg5 = (PyObject *) NULL ;
38328 wxSizerItem *result;
38329 PyObject * obj0 = 0 ;
38330 PyObject * obj1 = 0 ;
38331 PyObject * obj2 = 0 ;
38332 PyObject * obj3 = 0 ;
38333 PyObject * obj4 = 0 ;
38334 char *kwnames[] = {
38335 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38336 };
38337
38338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38340 if (SWIG_arg_fail(1)) SWIG_fail;
38341 {
38342 arg2 = (int)(SWIG_As_int(obj1));
38343 if (SWIG_arg_fail(2)) SWIG_fail;
38344 }
38345 {
38346 arg3 = (int)(SWIG_As_int(obj2));
38347 if (SWIG_arg_fail(3)) SWIG_fail;
38348 }
38349 {
38350 arg4 = (int)(SWIG_As_int(obj3));
38351 if (SWIG_arg_fail(4)) SWIG_fail;
38352 }
38353 if (obj4) {
38354 arg5 = obj4;
38355 }
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38359
38360 wxPyEndAllowThreads(__tstate);
38361 if (PyErr_Occurred()) SWIG_fail;
38362 }
38363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38364 return resultobj;
38365 fail:
38366 return NULL;
38367 }
38368
38369
38370 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38371 PyObject *resultobj;
38372 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38373 PyObject * obj0 = 0 ;
38374 char *kwnames[] = {
38375 (char *) "self", NULL
38376 };
38377
38378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38380 if (SWIG_arg_fail(1)) SWIG_fail;
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 (arg1)->DeleteWindows();
38384
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 Py_INCREF(Py_None); resultobj = Py_None;
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj;
38397 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38398 PyObject * obj0 = 0 ;
38399 char *kwnames[] = {
38400 (char *) "self", NULL
38401 };
38402
38403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) 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 {
38407 PyThreadState* __tstate = wxPyBeginAllowThreads();
38408 (arg1)->DetachSizer();
38409
38410 wxPyEndAllowThreads(__tstate);
38411 if (PyErr_Occurred()) SWIG_fail;
38412 }
38413 Py_INCREF(Py_None); resultobj = Py_None;
38414 return resultobj;
38415 fail:
38416 return NULL;
38417 }
38418
38419
38420 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38421 PyObject *resultobj;
38422 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38423 wxSize result;
38424 PyObject * obj0 = 0 ;
38425 char *kwnames[] = {
38426 (char *) "self", NULL
38427 };
38428
38429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38431 if (SWIG_arg_fail(1)) SWIG_fail;
38432 {
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (arg1)->GetSize();
38435
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 {
38440 wxSize * resultptr;
38441 resultptr = new wxSize((wxSize &)(result));
38442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38443 }
38444 return resultobj;
38445 fail:
38446 return NULL;
38447 }
38448
38449
38450 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38451 PyObject *resultobj;
38452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38453 wxSize result;
38454 PyObject * obj0 = 0 ;
38455 char *kwnames[] = {
38456 (char *) "self", NULL
38457 };
38458
38459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38461 if (SWIG_arg_fail(1)) SWIG_fail;
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 result = (arg1)->CalcMin();
38465
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 {
38470 wxSize * resultptr;
38471 resultptr = new wxSize((wxSize &)(result));
38472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38473 }
38474 return resultobj;
38475 fail:
38476 return NULL;
38477 }
38478
38479
38480 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38481 PyObject *resultobj;
38482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38483 wxPoint arg2 ;
38484 wxSize arg3 ;
38485 PyObject * obj0 = 0 ;
38486 PyObject * obj1 = 0 ;
38487 PyObject * obj2 = 0 ;
38488 char *kwnames[] = {
38489 (char *) "self",(char *) "pos",(char *) "size", NULL
38490 };
38491
38492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38494 if (SWIG_arg_fail(1)) SWIG_fail;
38495 {
38496 wxPoint * argp;
38497 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38498 if (SWIG_arg_fail(2)) SWIG_fail;
38499 if (argp == NULL) {
38500 SWIG_null_ref("wxPoint");
38501 }
38502 if (SWIG_arg_fail(2)) SWIG_fail;
38503 arg2 = *argp;
38504 }
38505 {
38506 wxSize * argp;
38507 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38508 if (SWIG_arg_fail(3)) SWIG_fail;
38509 if (argp == NULL) {
38510 SWIG_null_ref("wxSize");
38511 }
38512 if (SWIG_arg_fail(3)) SWIG_fail;
38513 arg3 = *argp;
38514 }
38515 {
38516 PyThreadState* __tstate = wxPyBeginAllowThreads();
38517 (arg1)->SetDimension(arg2,arg3);
38518
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 Py_INCREF(Py_None); resultobj = Py_None;
38523 return resultobj;
38524 fail:
38525 return NULL;
38526 }
38527
38528
38529 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38530 PyObject *resultobj;
38531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38532 wxSize result;
38533 PyObject * obj0 = 0 ;
38534 char *kwnames[] = {
38535 (char *) "self", NULL
38536 };
38537
38538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38540 if (SWIG_arg_fail(1)) SWIG_fail;
38541 {
38542 PyThreadState* __tstate = wxPyBeginAllowThreads();
38543 result = (arg1)->GetMinSize();
38544
38545 wxPyEndAllowThreads(__tstate);
38546 if (PyErr_Occurred()) SWIG_fail;
38547 }
38548 {
38549 wxSize * resultptr;
38550 resultptr = new wxSize((wxSize &)(result));
38551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38552 }
38553 return resultobj;
38554 fail:
38555 return NULL;
38556 }
38557
38558
38559 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj;
38561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38562 wxSize result;
38563 PyObject * obj0 = 0 ;
38564 char *kwnames[] = {
38565 (char *) "self", NULL
38566 };
38567
38568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38570 if (SWIG_arg_fail(1)) SWIG_fail;
38571 {
38572 PyThreadState* __tstate = wxPyBeginAllowThreads();
38573 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38574
38575 wxPyEndAllowThreads(__tstate);
38576 if (PyErr_Occurred()) SWIG_fail;
38577 }
38578 {
38579 wxSize * resultptr;
38580 resultptr = new wxSize((wxSize &)(result));
38581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38582 }
38583 return resultobj;
38584 fail:
38585 return NULL;
38586 }
38587
38588
38589 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38590 PyObject *resultobj;
38591 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38592 int arg2 ;
38593 int arg3 ;
38594 PyObject * obj0 = 0 ;
38595 PyObject * obj1 = 0 ;
38596 PyObject * obj2 = 0 ;
38597 char *kwnames[] = {
38598 (char *) "self",(char *) "x",(char *) "y", NULL
38599 };
38600
38601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38603 if (SWIG_arg_fail(1)) SWIG_fail;
38604 {
38605 arg2 = (int)(SWIG_As_int(obj1));
38606 if (SWIG_arg_fail(2)) SWIG_fail;
38607 }
38608 {
38609 arg3 = (int)(SWIG_As_int(obj2));
38610 if (SWIG_arg_fail(3)) SWIG_fail;
38611 }
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 (arg1)->SetInitSize(arg2,arg3);
38615
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 Py_INCREF(Py_None); resultobj = Py_None;
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj;
38628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38629 int arg2 ;
38630 int arg3 ;
38631 PyObject * obj0 = 0 ;
38632 PyObject * obj1 = 0 ;
38633 PyObject * obj2 = 0 ;
38634 char *kwnames[] = {
38635 (char *) "self",(char *) "width",(char *) "height", NULL
38636 };
38637
38638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
38643 if (SWIG_arg_fail(2)) SWIG_fail;
38644 }
38645 {
38646 arg3 = (int)(SWIG_As_int(obj2));
38647 if (SWIG_arg_fail(3)) SWIG_fail;
38648 }
38649 {
38650 PyThreadState* __tstate = wxPyBeginAllowThreads();
38651 (arg1)->SetRatio(arg2,arg3);
38652
38653 wxPyEndAllowThreads(__tstate);
38654 if (PyErr_Occurred()) SWIG_fail;
38655 }
38656 Py_INCREF(Py_None); resultobj = Py_None;
38657 return resultobj;
38658 fail:
38659 return NULL;
38660 }
38661
38662
38663 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38664 PyObject *resultobj;
38665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38666 wxSize *arg2 = 0 ;
38667 wxSize temp2 ;
38668 PyObject * obj0 = 0 ;
38669 PyObject * obj1 = 0 ;
38670 char *kwnames[] = {
38671 (char *) "self",(char *) "size", NULL
38672 };
38673
38674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38676 if (SWIG_arg_fail(1)) SWIG_fail;
38677 {
38678 arg2 = &temp2;
38679 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38680 }
38681 {
38682 PyThreadState* __tstate = wxPyBeginAllowThreads();
38683 (arg1)->SetRatio((wxSize const &)*arg2);
38684
38685 wxPyEndAllowThreads(__tstate);
38686 if (PyErr_Occurred()) SWIG_fail;
38687 }
38688 Py_INCREF(Py_None); resultobj = Py_None;
38689 return resultobj;
38690 fail:
38691 return NULL;
38692 }
38693
38694
38695 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38696 PyObject *resultobj;
38697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38698 float arg2 ;
38699 PyObject * obj0 = 0 ;
38700 PyObject * obj1 = 0 ;
38701 char *kwnames[] = {
38702 (char *) "self",(char *) "ratio", NULL
38703 };
38704
38705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38707 if (SWIG_arg_fail(1)) SWIG_fail;
38708 {
38709 arg2 = (float)(SWIG_As_float(obj1));
38710 if (SWIG_arg_fail(2)) SWIG_fail;
38711 }
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 (arg1)->SetRatio(arg2);
38715
38716 wxPyEndAllowThreads(__tstate);
38717 if (PyErr_Occurred()) SWIG_fail;
38718 }
38719 Py_INCREF(Py_None); resultobj = Py_None;
38720 return resultobj;
38721 fail:
38722 return NULL;
38723 }
38724
38725
38726 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38727 PyObject *resultobj;
38728 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38729 float result;
38730 PyObject * obj0 = 0 ;
38731 char *kwnames[] = {
38732 (char *) "self", NULL
38733 };
38734
38735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38737 if (SWIG_arg_fail(1)) SWIG_fail;
38738 {
38739 PyThreadState* __tstate = wxPyBeginAllowThreads();
38740 result = (float)(arg1)->GetRatio();
38741
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 {
38746 resultobj = SWIG_From_float((float)(result));
38747 }
38748 return resultobj;
38749 fail:
38750 return NULL;
38751 }
38752
38753
38754 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38755 PyObject *resultobj;
38756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38757 wxRect result;
38758 PyObject * obj0 = 0 ;
38759 char *kwnames[] = {
38760 (char *) "self", NULL
38761 };
38762
38763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38765 if (SWIG_arg_fail(1)) SWIG_fail;
38766 {
38767 PyThreadState* __tstate = wxPyBeginAllowThreads();
38768 result = (arg1)->GetRect();
38769
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 {
38774 wxRect * resultptr;
38775 resultptr = new wxRect((wxRect &)(result));
38776 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38777 }
38778 return resultobj;
38779 fail:
38780 return NULL;
38781 }
38782
38783
38784 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38785 PyObject *resultobj;
38786 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38787 bool result;
38788 PyObject * obj0 = 0 ;
38789 char *kwnames[] = {
38790 (char *) "self", NULL
38791 };
38792
38793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38795 if (SWIG_arg_fail(1)) SWIG_fail;
38796 {
38797 PyThreadState* __tstate = wxPyBeginAllowThreads();
38798 result = (bool)(arg1)->IsWindow();
38799
38800 wxPyEndAllowThreads(__tstate);
38801 if (PyErr_Occurred()) SWIG_fail;
38802 }
38803 {
38804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38805 }
38806 return resultobj;
38807 fail:
38808 return NULL;
38809 }
38810
38811
38812 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38813 PyObject *resultobj;
38814 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38815 bool result;
38816 PyObject * obj0 = 0 ;
38817 char *kwnames[] = {
38818 (char *) "self", NULL
38819 };
38820
38821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38823 if (SWIG_arg_fail(1)) SWIG_fail;
38824 {
38825 PyThreadState* __tstate = wxPyBeginAllowThreads();
38826 result = (bool)(arg1)->IsSizer();
38827
38828 wxPyEndAllowThreads(__tstate);
38829 if (PyErr_Occurred()) SWIG_fail;
38830 }
38831 {
38832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38833 }
38834 return resultobj;
38835 fail:
38836 return NULL;
38837 }
38838
38839
38840 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38841 PyObject *resultobj;
38842 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38843 bool result;
38844 PyObject * obj0 = 0 ;
38845 char *kwnames[] = {
38846 (char *) "self", NULL
38847 };
38848
38849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38851 if (SWIG_arg_fail(1)) SWIG_fail;
38852 {
38853 PyThreadState* __tstate = wxPyBeginAllowThreads();
38854 result = (bool)(arg1)->IsSpacer();
38855
38856 wxPyEndAllowThreads(__tstate);
38857 if (PyErr_Occurred()) SWIG_fail;
38858 }
38859 {
38860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38861 }
38862 return resultobj;
38863 fail:
38864 return NULL;
38865 }
38866
38867
38868 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38869 PyObject *resultobj;
38870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38871 int arg2 ;
38872 PyObject * obj0 = 0 ;
38873 PyObject * obj1 = 0 ;
38874 char *kwnames[] = {
38875 (char *) "self",(char *) "proportion", NULL
38876 };
38877
38878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38880 if (SWIG_arg_fail(1)) SWIG_fail;
38881 {
38882 arg2 = (int)(SWIG_As_int(obj1));
38883 if (SWIG_arg_fail(2)) SWIG_fail;
38884 }
38885 {
38886 PyThreadState* __tstate = wxPyBeginAllowThreads();
38887 (arg1)->SetProportion(arg2);
38888
38889 wxPyEndAllowThreads(__tstate);
38890 if (PyErr_Occurred()) SWIG_fail;
38891 }
38892 Py_INCREF(Py_None); resultobj = Py_None;
38893 return resultobj;
38894 fail:
38895 return NULL;
38896 }
38897
38898
38899 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38900 PyObject *resultobj;
38901 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38902 int result;
38903 PyObject * obj0 = 0 ;
38904 char *kwnames[] = {
38905 (char *) "self", NULL
38906 };
38907
38908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38910 if (SWIG_arg_fail(1)) SWIG_fail;
38911 {
38912 PyThreadState* __tstate = wxPyBeginAllowThreads();
38913 result = (int)(arg1)->GetProportion();
38914
38915 wxPyEndAllowThreads(__tstate);
38916 if (PyErr_Occurred()) SWIG_fail;
38917 }
38918 {
38919 resultobj = SWIG_From_int((int)(result));
38920 }
38921 return resultobj;
38922 fail:
38923 return NULL;
38924 }
38925
38926
38927 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38928 PyObject *resultobj;
38929 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38930 int arg2 ;
38931 PyObject * obj0 = 0 ;
38932 PyObject * obj1 = 0 ;
38933 char *kwnames[] = {
38934 (char *) "self",(char *) "flag", NULL
38935 };
38936
38937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38939 if (SWIG_arg_fail(1)) SWIG_fail;
38940 {
38941 arg2 = (int)(SWIG_As_int(obj1));
38942 if (SWIG_arg_fail(2)) SWIG_fail;
38943 }
38944 {
38945 PyThreadState* __tstate = wxPyBeginAllowThreads();
38946 (arg1)->SetFlag(arg2);
38947
38948 wxPyEndAllowThreads(__tstate);
38949 if (PyErr_Occurred()) SWIG_fail;
38950 }
38951 Py_INCREF(Py_None); resultobj = Py_None;
38952 return resultobj;
38953 fail:
38954 return NULL;
38955 }
38956
38957
38958 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38959 PyObject *resultobj;
38960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38961 int result;
38962 PyObject * obj0 = 0 ;
38963 char *kwnames[] = {
38964 (char *) "self", NULL
38965 };
38966
38967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38969 if (SWIG_arg_fail(1)) SWIG_fail;
38970 {
38971 PyThreadState* __tstate = wxPyBeginAllowThreads();
38972 result = (int)(arg1)->GetFlag();
38973
38974 wxPyEndAllowThreads(__tstate);
38975 if (PyErr_Occurred()) SWIG_fail;
38976 }
38977 {
38978 resultobj = SWIG_From_int((int)(result));
38979 }
38980 return resultobj;
38981 fail:
38982 return NULL;
38983 }
38984
38985
38986 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38987 PyObject *resultobj;
38988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38989 int arg2 ;
38990 PyObject * obj0 = 0 ;
38991 PyObject * obj1 = 0 ;
38992 char *kwnames[] = {
38993 (char *) "self",(char *) "border", NULL
38994 };
38995
38996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38998 if (SWIG_arg_fail(1)) SWIG_fail;
38999 {
39000 arg2 = (int)(SWIG_As_int(obj1));
39001 if (SWIG_arg_fail(2)) SWIG_fail;
39002 }
39003 {
39004 PyThreadState* __tstate = wxPyBeginAllowThreads();
39005 (arg1)->SetBorder(arg2);
39006
39007 wxPyEndAllowThreads(__tstate);
39008 if (PyErr_Occurred()) SWIG_fail;
39009 }
39010 Py_INCREF(Py_None); resultobj = Py_None;
39011 return resultobj;
39012 fail:
39013 return NULL;
39014 }
39015
39016
39017 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39018 PyObject *resultobj;
39019 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39020 int result;
39021 PyObject * obj0 = 0 ;
39022 char *kwnames[] = {
39023 (char *) "self", NULL
39024 };
39025
39026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39028 if (SWIG_arg_fail(1)) SWIG_fail;
39029 {
39030 PyThreadState* __tstate = wxPyBeginAllowThreads();
39031 result = (int)(arg1)->GetBorder();
39032
39033 wxPyEndAllowThreads(__tstate);
39034 if (PyErr_Occurred()) SWIG_fail;
39035 }
39036 {
39037 resultobj = SWIG_From_int((int)(result));
39038 }
39039 return resultobj;
39040 fail:
39041 return NULL;
39042 }
39043
39044
39045 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39046 PyObject *resultobj;
39047 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39048 wxWindow *result;
39049 PyObject * obj0 = 0 ;
39050 char *kwnames[] = {
39051 (char *) "self", NULL
39052 };
39053
39054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39056 if (SWIG_arg_fail(1)) SWIG_fail;
39057 {
39058 PyThreadState* __tstate = wxPyBeginAllowThreads();
39059 result = (wxWindow *)(arg1)->GetWindow();
39060
39061 wxPyEndAllowThreads(__tstate);
39062 if (PyErr_Occurred()) SWIG_fail;
39063 }
39064 {
39065 resultobj = wxPyMake_wxObject(result, 0);
39066 }
39067 return resultobj;
39068 fail:
39069 return NULL;
39070 }
39071
39072
39073 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39074 PyObject *resultobj;
39075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39076 wxWindow *arg2 = (wxWindow *) 0 ;
39077 PyObject * obj0 = 0 ;
39078 PyObject * obj1 = 0 ;
39079 char *kwnames[] = {
39080 (char *) "self",(char *) "window", NULL
39081 };
39082
39083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39085 if (SWIG_arg_fail(1)) SWIG_fail;
39086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39087 if (SWIG_arg_fail(2)) SWIG_fail;
39088 {
39089 PyThreadState* __tstate = wxPyBeginAllowThreads();
39090 (arg1)->SetWindow(arg2);
39091
39092 wxPyEndAllowThreads(__tstate);
39093 if (PyErr_Occurred()) SWIG_fail;
39094 }
39095 Py_INCREF(Py_None); resultobj = Py_None;
39096 return resultobj;
39097 fail:
39098 return NULL;
39099 }
39100
39101
39102 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39103 PyObject *resultobj;
39104 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39105 wxSizer *result;
39106 PyObject * obj0 = 0 ;
39107 char *kwnames[] = {
39108 (char *) "self", NULL
39109 };
39110
39111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39113 if (SWIG_arg_fail(1)) SWIG_fail;
39114 {
39115 PyThreadState* __tstate = wxPyBeginAllowThreads();
39116 result = (wxSizer *)(arg1)->GetSizer();
39117
39118 wxPyEndAllowThreads(__tstate);
39119 if (PyErr_Occurred()) SWIG_fail;
39120 }
39121 {
39122 resultobj = wxPyMake_wxSizer(result, 0);
39123 }
39124 return resultobj;
39125 fail:
39126 return NULL;
39127 }
39128
39129
39130 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39131 PyObject *resultobj;
39132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39133 wxSizer *arg2 = (wxSizer *) 0 ;
39134 PyObject * obj0 = 0 ;
39135 PyObject * obj1 = 0 ;
39136 char *kwnames[] = {
39137 (char *) "self",(char *) "sizer", NULL
39138 };
39139
39140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39142 if (SWIG_arg_fail(1)) SWIG_fail;
39143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39144 if (SWIG_arg_fail(2)) SWIG_fail;
39145 {
39146 PyThreadState* __tstate = wxPyBeginAllowThreads();
39147 (arg1)->SetSizer(arg2);
39148
39149 wxPyEndAllowThreads(__tstate);
39150 if (PyErr_Occurred()) SWIG_fail;
39151 }
39152 Py_INCREF(Py_None); resultobj = Py_None;
39153 return resultobj;
39154 fail:
39155 return NULL;
39156 }
39157
39158
39159 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39160 PyObject *resultobj;
39161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39162 wxSize *result;
39163 PyObject * obj0 = 0 ;
39164 char *kwnames[] = {
39165 (char *) "self", NULL
39166 };
39167
39168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39170 if (SWIG_arg_fail(1)) SWIG_fail;
39171 {
39172 PyThreadState* __tstate = wxPyBeginAllowThreads();
39173 {
39174 wxSize const &_result_ref = (arg1)->GetSpacer();
39175 result = (wxSize *) &_result_ref;
39176 }
39177
39178 wxPyEndAllowThreads(__tstate);
39179 if (PyErr_Occurred()) SWIG_fail;
39180 }
39181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39189 PyObject *resultobj;
39190 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39191 wxSize *arg2 = 0 ;
39192 wxSize temp2 ;
39193 PyObject * obj0 = 0 ;
39194 PyObject * obj1 = 0 ;
39195 char *kwnames[] = {
39196 (char *) "self",(char *) "size", NULL
39197 };
39198
39199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39201 if (SWIG_arg_fail(1)) SWIG_fail;
39202 {
39203 arg2 = &temp2;
39204 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39205 }
39206 {
39207 PyThreadState* __tstate = wxPyBeginAllowThreads();
39208 (arg1)->SetSpacer((wxSize const &)*arg2);
39209
39210 wxPyEndAllowThreads(__tstate);
39211 if (PyErr_Occurred()) SWIG_fail;
39212 }
39213 Py_INCREF(Py_None); resultobj = Py_None;
39214 return resultobj;
39215 fail:
39216 return NULL;
39217 }
39218
39219
39220 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39221 PyObject *resultobj;
39222 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39223 bool arg2 ;
39224 PyObject * obj0 = 0 ;
39225 PyObject * obj1 = 0 ;
39226 char *kwnames[] = {
39227 (char *) "self",(char *) "show", NULL
39228 };
39229
39230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39232 if (SWIG_arg_fail(1)) SWIG_fail;
39233 {
39234 arg2 = (bool)(SWIG_As_bool(obj1));
39235 if (SWIG_arg_fail(2)) SWIG_fail;
39236 }
39237 {
39238 PyThreadState* __tstate = wxPyBeginAllowThreads();
39239 (arg1)->Show(arg2);
39240
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 Py_INCREF(Py_None); resultobj = Py_None;
39245 return resultobj;
39246 fail:
39247 return NULL;
39248 }
39249
39250
39251 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39252 PyObject *resultobj;
39253 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39254 bool result;
39255 PyObject * obj0 = 0 ;
39256 char *kwnames[] = {
39257 (char *) "self", NULL
39258 };
39259
39260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39262 if (SWIG_arg_fail(1)) SWIG_fail;
39263 {
39264 PyThreadState* __tstate = wxPyBeginAllowThreads();
39265 result = (bool)(arg1)->IsShown();
39266
39267 wxPyEndAllowThreads(__tstate);
39268 if (PyErr_Occurred()) SWIG_fail;
39269 }
39270 {
39271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39272 }
39273 return resultobj;
39274 fail:
39275 return NULL;
39276 }
39277
39278
39279 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39280 PyObject *resultobj;
39281 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39282 wxPoint result;
39283 PyObject * obj0 = 0 ;
39284 char *kwnames[] = {
39285 (char *) "self", NULL
39286 };
39287
39288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39290 if (SWIG_arg_fail(1)) SWIG_fail;
39291 {
39292 PyThreadState* __tstate = wxPyBeginAllowThreads();
39293 result = (arg1)->GetPosition();
39294
39295 wxPyEndAllowThreads(__tstate);
39296 if (PyErr_Occurred()) SWIG_fail;
39297 }
39298 {
39299 wxPoint * resultptr;
39300 resultptr = new wxPoint((wxPoint &)(result));
39301 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39302 }
39303 return resultobj;
39304 fail:
39305 return NULL;
39306 }
39307
39308
39309 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39310 PyObject *resultobj;
39311 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39312 PyObject *result;
39313 PyObject * obj0 = 0 ;
39314 char *kwnames[] = {
39315 (char *) "self", NULL
39316 };
39317
39318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39320 if (SWIG_arg_fail(1)) SWIG_fail;
39321 {
39322 PyThreadState* __tstate = wxPyBeginAllowThreads();
39323 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39324
39325 wxPyEndAllowThreads(__tstate);
39326 if (PyErr_Occurred()) SWIG_fail;
39327 }
39328 resultobj = result;
39329 return resultobj;
39330 fail:
39331 return NULL;
39332 }
39333
39334
39335 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39336 PyObject *obj;
39337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39338 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39339 Py_INCREF(obj);
39340 return Py_BuildValue((char *)"");
39341 }
39342 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39343 PyObject *resultobj;
39344 wxSizer *arg1 = (wxSizer *) 0 ;
39345 PyObject *arg2 = (PyObject *) 0 ;
39346 PyObject * obj0 = 0 ;
39347 PyObject * obj1 = 0 ;
39348 char *kwnames[] = {
39349 (char *) "self",(char *) "_self", NULL
39350 };
39351
39352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39354 if (SWIG_arg_fail(1)) SWIG_fail;
39355 arg2 = obj1;
39356 {
39357 PyThreadState* __tstate = wxPyBeginAllowThreads();
39358 wxSizer__setOORInfo(arg1,arg2);
39359
39360 wxPyEndAllowThreads(__tstate);
39361 if (PyErr_Occurred()) SWIG_fail;
39362 }
39363 Py_INCREF(Py_None); resultobj = Py_None;
39364 return resultobj;
39365 fail:
39366 return NULL;
39367 }
39368
39369
39370 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39371 PyObject *resultobj;
39372 wxSizer *arg1 = (wxSizer *) 0 ;
39373 PyObject *arg2 = (PyObject *) 0 ;
39374 int arg3 = (int) 0 ;
39375 int arg4 = (int) 0 ;
39376 int arg5 = (int) 0 ;
39377 PyObject *arg6 = (PyObject *) NULL ;
39378 wxSizerItem *result;
39379 PyObject * obj0 = 0 ;
39380 PyObject * obj1 = 0 ;
39381 PyObject * obj2 = 0 ;
39382 PyObject * obj3 = 0 ;
39383 PyObject * obj4 = 0 ;
39384 PyObject * obj5 = 0 ;
39385 char *kwnames[] = {
39386 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39387 };
39388
39389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39391 if (SWIG_arg_fail(1)) SWIG_fail;
39392 arg2 = obj1;
39393 if (obj2) {
39394 {
39395 arg3 = (int)(SWIG_As_int(obj2));
39396 if (SWIG_arg_fail(3)) SWIG_fail;
39397 }
39398 }
39399 if (obj3) {
39400 {
39401 arg4 = (int)(SWIG_As_int(obj3));
39402 if (SWIG_arg_fail(4)) SWIG_fail;
39403 }
39404 }
39405 if (obj4) {
39406 {
39407 arg5 = (int)(SWIG_As_int(obj4));
39408 if (SWIG_arg_fail(5)) SWIG_fail;
39409 }
39410 }
39411 if (obj5) {
39412 arg6 = obj5;
39413 }
39414 {
39415 PyThreadState* __tstate = wxPyBeginAllowThreads();
39416 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39417
39418 wxPyEndAllowThreads(__tstate);
39419 if (PyErr_Occurred()) SWIG_fail;
39420 }
39421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39422 return resultobj;
39423 fail:
39424 return NULL;
39425 }
39426
39427
39428 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39429 PyObject *resultobj;
39430 wxSizer *arg1 = (wxSizer *) 0 ;
39431 int arg2 ;
39432 PyObject *arg3 = (PyObject *) 0 ;
39433 int arg4 = (int) 0 ;
39434 int arg5 = (int) 0 ;
39435 int arg6 = (int) 0 ;
39436 PyObject *arg7 = (PyObject *) NULL ;
39437 wxSizerItem *result;
39438 PyObject * obj0 = 0 ;
39439 PyObject * obj1 = 0 ;
39440 PyObject * obj2 = 0 ;
39441 PyObject * obj3 = 0 ;
39442 PyObject * obj4 = 0 ;
39443 PyObject * obj5 = 0 ;
39444 PyObject * obj6 = 0 ;
39445 char *kwnames[] = {
39446 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39447 };
39448
39449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39451 if (SWIG_arg_fail(1)) SWIG_fail;
39452 {
39453 arg2 = (int)(SWIG_As_int(obj1));
39454 if (SWIG_arg_fail(2)) SWIG_fail;
39455 }
39456 arg3 = obj2;
39457 if (obj3) {
39458 {
39459 arg4 = (int)(SWIG_As_int(obj3));
39460 if (SWIG_arg_fail(4)) SWIG_fail;
39461 }
39462 }
39463 if (obj4) {
39464 {
39465 arg5 = (int)(SWIG_As_int(obj4));
39466 if (SWIG_arg_fail(5)) SWIG_fail;
39467 }
39468 }
39469 if (obj5) {
39470 {
39471 arg6 = (int)(SWIG_As_int(obj5));
39472 if (SWIG_arg_fail(6)) SWIG_fail;
39473 }
39474 }
39475 if (obj6) {
39476 arg7 = obj6;
39477 }
39478 {
39479 PyThreadState* __tstate = wxPyBeginAllowThreads();
39480 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39481
39482 wxPyEndAllowThreads(__tstate);
39483 if (PyErr_Occurred()) SWIG_fail;
39484 }
39485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39486 return resultobj;
39487 fail:
39488 return NULL;
39489 }
39490
39491
39492 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39493 PyObject *resultobj;
39494 wxSizer *arg1 = (wxSizer *) 0 ;
39495 PyObject *arg2 = (PyObject *) 0 ;
39496 int arg3 = (int) 0 ;
39497 int arg4 = (int) 0 ;
39498 int arg5 = (int) 0 ;
39499 PyObject *arg6 = (PyObject *) NULL ;
39500 wxSizerItem *result;
39501 PyObject * obj0 = 0 ;
39502 PyObject * obj1 = 0 ;
39503 PyObject * obj2 = 0 ;
39504 PyObject * obj3 = 0 ;
39505 PyObject * obj4 = 0 ;
39506 PyObject * obj5 = 0 ;
39507 char *kwnames[] = {
39508 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39509 };
39510
39511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39513 if (SWIG_arg_fail(1)) SWIG_fail;
39514 arg2 = obj1;
39515 if (obj2) {
39516 {
39517 arg3 = (int)(SWIG_As_int(obj2));
39518 if (SWIG_arg_fail(3)) SWIG_fail;
39519 }
39520 }
39521 if (obj3) {
39522 {
39523 arg4 = (int)(SWIG_As_int(obj3));
39524 if (SWIG_arg_fail(4)) SWIG_fail;
39525 }
39526 }
39527 if (obj4) {
39528 {
39529 arg5 = (int)(SWIG_As_int(obj4));
39530 if (SWIG_arg_fail(5)) SWIG_fail;
39531 }
39532 }
39533 if (obj5) {
39534 arg6 = obj5;
39535 }
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39539
39540 wxPyEndAllowThreads(__tstate);
39541 if (PyErr_Occurred()) SWIG_fail;
39542 }
39543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39544 return resultobj;
39545 fail:
39546 return NULL;
39547 }
39548
39549
39550 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39551 PyObject *resultobj;
39552 wxSizer *arg1 = (wxSizer *) 0 ;
39553 PyObject *arg2 = (PyObject *) 0 ;
39554 bool result;
39555 PyObject * obj0 = 0 ;
39556 PyObject * obj1 = 0 ;
39557 char *kwnames[] = {
39558 (char *) "self",(char *) "item", NULL
39559 };
39560
39561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39563 if (SWIG_arg_fail(1)) SWIG_fail;
39564 arg2 = obj1;
39565 {
39566 PyThreadState* __tstate = wxPyBeginAllowThreads();
39567 result = (bool)wxSizer_Remove(arg1,arg2);
39568
39569 wxPyEndAllowThreads(__tstate);
39570 if (PyErr_Occurred()) SWIG_fail;
39571 }
39572 {
39573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39574 }
39575 return resultobj;
39576 fail:
39577 return NULL;
39578 }
39579
39580
39581 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39582 PyObject *resultobj;
39583 wxSizer *arg1 = (wxSizer *) 0 ;
39584 PyObject *arg2 = (PyObject *) 0 ;
39585 bool result;
39586 PyObject * obj0 = 0 ;
39587 PyObject * obj1 = 0 ;
39588 char *kwnames[] = {
39589 (char *) "self",(char *) "item", NULL
39590 };
39591
39592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39594 if (SWIG_arg_fail(1)) SWIG_fail;
39595 arg2 = obj1;
39596 {
39597 PyThreadState* __tstate = wxPyBeginAllowThreads();
39598 result = (bool)wxSizer_Detach(arg1,arg2);
39599
39600 wxPyEndAllowThreads(__tstate);
39601 if (PyErr_Occurred()) SWIG_fail;
39602 }
39603 {
39604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39605 }
39606 return resultobj;
39607 fail:
39608 return NULL;
39609 }
39610
39611
39612 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39613 PyObject *resultobj;
39614 wxSizer *arg1 = (wxSizer *) 0 ;
39615 PyObject *arg2 = (PyObject *) 0 ;
39616 wxSizerItem *result;
39617 PyObject * obj0 = 0 ;
39618 PyObject * obj1 = 0 ;
39619 char *kwnames[] = {
39620 (char *) "self",(char *) "item", NULL
39621 };
39622
39623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39625 if (SWIG_arg_fail(1)) SWIG_fail;
39626 arg2 = obj1;
39627 {
39628 PyThreadState* __tstate = wxPyBeginAllowThreads();
39629 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39630
39631 wxPyEndAllowThreads(__tstate);
39632 if (PyErr_Occurred()) SWIG_fail;
39633 }
39634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39635 return resultobj;
39636 fail:
39637 return NULL;
39638 }
39639
39640
39641 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39642 PyObject *resultobj;
39643 wxSizer *arg1 = (wxSizer *) 0 ;
39644 PyObject *arg2 = (PyObject *) 0 ;
39645 wxSize *arg3 = 0 ;
39646 wxSize temp3 ;
39647 PyObject * obj0 = 0 ;
39648 PyObject * obj1 = 0 ;
39649 PyObject * obj2 = 0 ;
39650 char *kwnames[] = {
39651 (char *) "self",(char *) "item",(char *) "size", NULL
39652 };
39653
39654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39656 if (SWIG_arg_fail(1)) SWIG_fail;
39657 arg2 = obj1;
39658 {
39659 arg3 = &temp3;
39660 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39661 }
39662 {
39663 PyThreadState* __tstate = wxPyBeginAllowThreads();
39664 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39665
39666 wxPyEndAllowThreads(__tstate);
39667 if (PyErr_Occurred()) SWIG_fail;
39668 }
39669 Py_INCREF(Py_None); resultobj = Py_None;
39670 return resultobj;
39671 fail:
39672 return NULL;
39673 }
39674
39675
39676 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39677 PyObject *resultobj;
39678 wxSizer *arg1 = (wxSizer *) 0 ;
39679 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39680 wxSizerItem *result;
39681 PyObject * obj0 = 0 ;
39682 PyObject * obj1 = 0 ;
39683 char *kwnames[] = {
39684 (char *) "self",(char *) "item", NULL
39685 };
39686
39687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39689 if (SWIG_arg_fail(1)) SWIG_fail;
39690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39691 if (SWIG_arg_fail(2)) SWIG_fail;
39692 {
39693 PyThreadState* __tstate = wxPyBeginAllowThreads();
39694 result = (wxSizerItem *)(arg1)->Add(arg2);
39695
39696 wxPyEndAllowThreads(__tstate);
39697 if (PyErr_Occurred()) SWIG_fail;
39698 }
39699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39700 return resultobj;
39701 fail:
39702 return NULL;
39703 }
39704
39705
39706 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39707 PyObject *resultobj;
39708 wxSizer *arg1 = (wxSizer *) 0 ;
39709 size_t arg2 ;
39710 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39711 wxSizerItem *result;
39712 PyObject * obj0 = 0 ;
39713 PyObject * obj1 = 0 ;
39714 PyObject * obj2 = 0 ;
39715 char *kwnames[] = {
39716 (char *) "self",(char *) "index",(char *) "item", NULL
39717 };
39718
39719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39721 if (SWIG_arg_fail(1)) SWIG_fail;
39722 {
39723 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39724 if (SWIG_arg_fail(2)) SWIG_fail;
39725 }
39726 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39727 if (SWIG_arg_fail(3)) SWIG_fail;
39728 {
39729 PyThreadState* __tstate = wxPyBeginAllowThreads();
39730 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39731
39732 wxPyEndAllowThreads(__tstate);
39733 if (PyErr_Occurred()) SWIG_fail;
39734 }
39735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39736 return resultobj;
39737 fail:
39738 return NULL;
39739 }
39740
39741
39742 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39743 PyObject *resultobj;
39744 wxSizer *arg1 = (wxSizer *) 0 ;
39745 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39746 wxSizerItem *result;
39747 PyObject * obj0 = 0 ;
39748 PyObject * obj1 = 0 ;
39749 char *kwnames[] = {
39750 (char *) "self",(char *) "item", NULL
39751 };
39752
39753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39755 if (SWIG_arg_fail(1)) SWIG_fail;
39756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39757 if (SWIG_arg_fail(2)) SWIG_fail;
39758 {
39759 PyThreadState* __tstate = wxPyBeginAllowThreads();
39760 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39761
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39766 return resultobj;
39767 fail:
39768 return NULL;
39769 }
39770
39771
39772 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39773 PyObject *resultobj;
39774 wxSizer *arg1 = (wxSizer *) 0 ;
39775 int arg2 ;
39776 int arg3 ;
39777 int arg4 ;
39778 int arg5 ;
39779 PyObject * obj0 = 0 ;
39780 PyObject * obj1 = 0 ;
39781 PyObject * obj2 = 0 ;
39782 PyObject * obj3 = 0 ;
39783 PyObject * obj4 = 0 ;
39784 char *kwnames[] = {
39785 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39786 };
39787
39788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39790 if (SWIG_arg_fail(1)) SWIG_fail;
39791 {
39792 arg2 = (int)(SWIG_As_int(obj1));
39793 if (SWIG_arg_fail(2)) SWIG_fail;
39794 }
39795 {
39796 arg3 = (int)(SWIG_As_int(obj2));
39797 if (SWIG_arg_fail(3)) SWIG_fail;
39798 }
39799 {
39800 arg4 = (int)(SWIG_As_int(obj3));
39801 if (SWIG_arg_fail(4)) SWIG_fail;
39802 }
39803 {
39804 arg5 = (int)(SWIG_As_int(obj4));
39805 if (SWIG_arg_fail(5)) SWIG_fail;
39806 }
39807 {
39808 PyThreadState* __tstate = wxPyBeginAllowThreads();
39809 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39810
39811 wxPyEndAllowThreads(__tstate);
39812 if (PyErr_Occurred()) SWIG_fail;
39813 }
39814 Py_INCREF(Py_None); resultobj = Py_None;
39815 return resultobj;
39816 fail:
39817 return NULL;
39818 }
39819
39820
39821 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39822 PyObject *resultobj;
39823 wxSizer *arg1 = (wxSizer *) 0 ;
39824 wxSize *arg2 = 0 ;
39825 wxSize temp2 ;
39826 PyObject * obj0 = 0 ;
39827 PyObject * obj1 = 0 ;
39828 char *kwnames[] = {
39829 (char *) "self",(char *) "size", NULL
39830 };
39831
39832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39834 if (SWIG_arg_fail(1)) SWIG_fail;
39835 {
39836 arg2 = &temp2;
39837 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39838 }
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 (arg1)->SetMinSize((wxSize const &)*arg2);
39842
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 Py_INCREF(Py_None); resultobj = Py_None;
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj;
39855 wxSizer *arg1 = (wxSizer *) 0 ;
39856 wxSize result;
39857 PyObject * obj0 = 0 ;
39858 char *kwnames[] = {
39859 (char *) "self", NULL
39860 };
39861
39862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39864 if (SWIG_arg_fail(1)) SWIG_fail;
39865 {
39866 PyThreadState* __tstate = wxPyBeginAllowThreads();
39867 result = (arg1)->GetSize();
39868
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 {
39873 wxSize * resultptr;
39874 resultptr = new wxSize((wxSize &)(result));
39875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39876 }
39877 return resultobj;
39878 fail:
39879 return NULL;
39880 }
39881
39882
39883 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39884 PyObject *resultobj;
39885 wxSizer *arg1 = (wxSizer *) 0 ;
39886 wxPoint result;
39887 PyObject * obj0 = 0 ;
39888 char *kwnames[] = {
39889 (char *) "self", NULL
39890 };
39891
39892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39894 if (SWIG_arg_fail(1)) SWIG_fail;
39895 {
39896 PyThreadState* __tstate = wxPyBeginAllowThreads();
39897 result = (arg1)->GetPosition();
39898
39899 wxPyEndAllowThreads(__tstate);
39900 if (PyErr_Occurred()) SWIG_fail;
39901 }
39902 {
39903 wxPoint * resultptr;
39904 resultptr = new wxPoint((wxPoint &)(result));
39905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39906 }
39907 return resultobj;
39908 fail:
39909 return NULL;
39910 }
39911
39912
39913 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39914 PyObject *resultobj;
39915 wxSizer *arg1 = (wxSizer *) 0 ;
39916 wxSize result;
39917 PyObject * obj0 = 0 ;
39918 char *kwnames[] = {
39919 (char *) "self", NULL
39920 };
39921
39922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39924 if (SWIG_arg_fail(1)) SWIG_fail;
39925 {
39926 PyThreadState* __tstate = wxPyBeginAllowThreads();
39927 result = (arg1)->GetMinSize();
39928
39929 wxPyEndAllowThreads(__tstate);
39930 if (PyErr_Occurred()) SWIG_fail;
39931 }
39932 {
39933 wxSize * resultptr;
39934 resultptr = new wxSize((wxSize &)(result));
39935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39936 }
39937 return resultobj;
39938 fail:
39939 return NULL;
39940 }
39941
39942
39943 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39944 PyObject *resultobj;
39945 wxSizer *arg1 = (wxSizer *) 0 ;
39946 PyObject * obj0 = 0 ;
39947 char *kwnames[] = {
39948 (char *) "self", NULL
39949 };
39950
39951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39953 if (SWIG_arg_fail(1)) SWIG_fail;
39954 {
39955 PyThreadState* __tstate = wxPyBeginAllowThreads();
39956 (arg1)->RecalcSizes();
39957
39958 wxPyEndAllowThreads(__tstate);
39959 if (PyErr_Occurred()) SWIG_fail;
39960 }
39961 Py_INCREF(Py_None); resultobj = Py_None;
39962 return resultobj;
39963 fail:
39964 return NULL;
39965 }
39966
39967
39968 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39969 PyObject *resultobj;
39970 wxSizer *arg1 = (wxSizer *) 0 ;
39971 wxSize result;
39972 PyObject * obj0 = 0 ;
39973 char *kwnames[] = {
39974 (char *) "self", NULL
39975 };
39976
39977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39979 if (SWIG_arg_fail(1)) SWIG_fail;
39980 {
39981 PyThreadState* __tstate = wxPyBeginAllowThreads();
39982 result = (arg1)->CalcMin();
39983
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 {
39988 wxSize * resultptr;
39989 resultptr = new wxSize((wxSize &)(result));
39990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39991 }
39992 return resultobj;
39993 fail:
39994 return NULL;
39995 }
39996
39997
39998 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39999 PyObject *resultobj;
40000 wxSizer *arg1 = (wxSizer *) 0 ;
40001 PyObject * obj0 = 0 ;
40002 char *kwnames[] = {
40003 (char *) "self", NULL
40004 };
40005
40006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40008 if (SWIG_arg_fail(1)) SWIG_fail;
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 (arg1)->Layout();
40012
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 Py_INCREF(Py_None); resultobj = Py_None;
40017 return resultobj;
40018 fail:
40019 return NULL;
40020 }
40021
40022
40023 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40024 PyObject *resultobj;
40025 wxSizer *arg1 = (wxSizer *) 0 ;
40026 wxWindow *arg2 = (wxWindow *) 0 ;
40027 wxSize result;
40028 PyObject * obj0 = 0 ;
40029 PyObject * obj1 = 0 ;
40030 char *kwnames[] = {
40031 (char *) "self",(char *) "window", NULL
40032 };
40033
40034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40036 if (SWIG_arg_fail(1)) SWIG_fail;
40037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40038 if (SWIG_arg_fail(2)) SWIG_fail;
40039 {
40040 PyThreadState* __tstate = wxPyBeginAllowThreads();
40041 result = (arg1)->Fit(arg2);
40042
40043 wxPyEndAllowThreads(__tstate);
40044 if (PyErr_Occurred()) SWIG_fail;
40045 }
40046 {
40047 wxSize * resultptr;
40048 resultptr = new wxSize((wxSize &)(result));
40049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40050 }
40051 return resultobj;
40052 fail:
40053 return NULL;
40054 }
40055
40056
40057 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40058 PyObject *resultobj;
40059 wxSizer *arg1 = (wxSizer *) 0 ;
40060 wxWindow *arg2 = (wxWindow *) 0 ;
40061 PyObject * obj0 = 0 ;
40062 PyObject * obj1 = 0 ;
40063 char *kwnames[] = {
40064 (char *) "self",(char *) "window", NULL
40065 };
40066
40067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40069 if (SWIG_arg_fail(1)) SWIG_fail;
40070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40071 if (SWIG_arg_fail(2)) SWIG_fail;
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 (arg1)->FitInside(arg2);
40075
40076 wxPyEndAllowThreads(__tstate);
40077 if (PyErr_Occurred()) SWIG_fail;
40078 }
40079 Py_INCREF(Py_None); resultobj = Py_None;
40080 return resultobj;
40081 fail:
40082 return NULL;
40083 }
40084
40085
40086 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40087 PyObject *resultobj;
40088 wxSizer *arg1 = (wxSizer *) 0 ;
40089 wxWindow *arg2 = (wxWindow *) 0 ;
40090 PyObject * obj0 = 0 ;
40091 PyObject * obj1 = 0 ;
40092 char *kwnames[] = {
40093 (char *) "self",(char *) "window", NULL
40094 };
40095
40096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40098 if (SWIG_arg_fail(1)) SWIG_fail;
40099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40100 if (SWIG_arg_fail(2)) SWIG_fail;
40101 {
40102 PyThreadState* __tstate = wxPyBeginAllowThreads();
40103 (arg1)->SetSizeHints(arg2);
40104
40105 wxPyEndAllowThreads(__tstate);
40106 if (PyErr_Occurred()) SWIG_fail;
40107 }
40108 Py_INCREF(Py_None); resultobj = Py_None;
40109 return resultobj;
40110 fail:
40111 return NULL;
40112 }
40113
40114
40115 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40116 PyObject *resultobj;
40117 wxSizer *arg1 = (wxSizer *) 0 ;
40118 wxWindow *arg2 = (wxWindow *) 0 ;
40119 PyObject * obj0 = 0 ;
40120 PyObject * obj1 = 0 ;
40121 char *kwnames[] = {
40122 (char *) "self",(char *) "window", NULL
40123 };
40124
40125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40127 if (SWIG_arg_fail(1)) SWIG_fail;
40128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40129 if (SWIG_arg_fail(2)) SWIG_fail;
40130 {
40131 PyThreadState* __tstate = wxPyBeginAllowThreads();
40132 (arg1)->SetVirtualSizeHints(arg2);
40133
40134 wxPyEndAllowThreads(__tstate);
40135 if (PyErr_Occurred()) SWIG_fail;
40136 }
40137 Py_INCREF(Py_None); resultobj = Py_None;
40138 return resultobj;
40139 fail:
40140 return NULL;
40141 }
40142
40143
40144 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40145 PyObject *resultobj;
40146 wxSizer *arg1 = (wxSizer *) 0 ;
40147 bool arg2 = (bool) false ;
40148 PyObject * obj0 = 0 ;
40149 PyObject * obj1 = 0 ;
40150 char *kwnames[] = {
40151 (char *) "self",(char *) "deleteWindows", NULL
40152 };
40153
40154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40156 if (SWIG_arg_fail(1)) SWIG_fail;
40157 if (obj1) {
40158 {
40159 arg2 = (bool)(SWIG_As_bool(obj1));
40160 if (SWIG_arg_fail(2)) SWIG_fail;
40161 }
40162 }
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 (arg1)->Clear(arg2);
40166
40167 wxPyEndAllowThreads(__tstate);
40168 if (PyErr_Occurred()) SWIG_fail;
40169 }
40170 Py_INCREF(Py_None); resultobj = Py_None;
40171 return resultobj;
40172 fail:
40173 return NULL;
40174 }
40175
40176
40177 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40178 PyObject *resultobj;
40179 wxSizer *arg1 = (wxSizer *) 0 ;
40180 PyObject * obj0 = 0 ;
40181 char *kwnames[] = {
40182 (char *) "self", NULL
40183 };
40184
40185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40187 if (SWIG_arg_fail(1)) SWIG_fail;
40188 {
40189 PyThreadState* __tstate = wxPyBeginAllowThreads();
40190 (arg1)->DeleteWindows();
40191
40192 wxPyEndAllowThreads(__tstate);
40193 if (PyErr_Occurred()) SWIG_fail;
40194 }
40195 Py_INCREF(Py_None); resultobj = Py_None;
40196 return resultobj;
40197 fail:
40198 return NULL;
40199 }
40200
40201
40202 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40203 PyObject *resultobj;
40204 wxSizer *arg1 = (wxSizer *) 0 ;
40205 PyObject *result;
40206 PyObject * obj0 = 0 ;
40207 char *kwnames[] = {
40208 (char *) "self", NULL
40209 };
40210
40211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40213 if (SWIG_arg_fail(1)) SWIG_fail;
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 result = (PyObject *)wxSizer_GetChildren(arg1);
40217
40218 wxPyEndAllowThreads(__tstate);
40219 if (PyErr_Occurred()) SWIG_fail;
40220 }
40221 resultobj = result;
40222 return resultobj;
40223 fail:
40224 return NULL;
40225 }
40226
40227
40228 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40229 PyObject *resultobj;
40230 wxSizer *arg1 = (wxSizer *) 0 ;
40231 PyObject *arg2 = (PyObject *) 0 ;
40232 bool arg3 = (bool) true ;
40233 bool arg4 = (bool) false ;
40234 bool result;
40235 PyObject * obj0 = 0 ;
40236 PyObject * obj1 = 0 ;
40237 PyObject * obj2 = 0 ;
40238 PyObject * obj3 = 0 ;
40239 char *kwnames[] = {
40240 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40241 };
40242
40243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40245 if (SWIG_arg_fail(1)) SWIG_fail;
40246 arg2 = obj1;
40247 if (obj2) {
40248 {
40249 arg3 = (bool)(SWIG_As_bool(obj2));
40250 if (SWIG_arg_fail(3)) SWIG_fail;
40251 }
40252 }
40253 if (obj3) {
40254 {
40255 arg4 = (bool)(SWIG_As_bool(obj3));
40256 if (SWIG_arg_fail(4)) SWIG_fail;
40257 }
40258 }
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40262
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 {
40267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40268 }
40269 return resultobj;
40270 fail:
40271 return NULL;
40272 }
40273
40274
40275 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40276 PyObject *resultobj;
40277 wxSizer *arg1 = (wxSizer *) 0 ;
40278 PyObject *arg2 = (PyObject *) 0 ;
40279 bool result;
40280 PyObject * obj0 = 0 ;
40281 PyObject * obj1 = 0 ;
40282 char *kwnames[] = {
40283 (char *) "self",(char *) "item", NULL
40284 };
40285
40286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40288 if (SWIG_arg_fail(1)) SWIG_fail;
40289 arg2 = obj1;
40290 {
40291 PyThreadState* __tstate = wxPyBeginAllowThreads();
40292 result = (bool)wxSizer_IsShown(arg1,arg2);
40293
40294 wxPyEndAllowThreads(__tstate);
40295 if (PyErr_Occurred()) SWIG_fail;
40296 }
40297 {
40298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40299 }
40300 return resultobj;
40301 fail:
40302 return NULL;
40303 }
40304
40305
40306 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40307 PyObject *resultobj;
40308 wxSizer *arg1 = (wxSizer *) 0 ;
40309 bool arg2 ;
40310 PyObject * obj0 = 0 ;
40311 PyObject * obj1 = 0 ;
40312 char *kwnames[] = {
40313 (char *) "self",(char *) "show", NULL
40314 };
40315
40316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40318 if (SWIG_arg_fail(1)) SWIG_fail;
40319 {
40320 arg2 = (bool)(SWIG_As_bool(obj1));
40321 if (SWIG_arg_fail(2)) SWIG_fail;
40322 }
40323 {
40324 PyThreadState* __tstate = wxPyBeginAllowThreads();
40325 (arg1)->ShowItems(arg2);
40326
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 Py_INCREF(Py_None); resultobj = Py_None;
40331 return resultobj;
40332 fail:
40333 return NULL;
40334 }
40335
40336
40337 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40338 PyObject *obj;
40339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40340 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40341 Py_INCREF(obj);
40342 return Py_BuildValue((char *)"");
40343 }
40344 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40345 PyObject *resultobj;
40346 wxPySizer *result;
40347 char *kwnames[] = {
40348 NULL
40349 };
40350
40351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40352 {
40353 PyThreadState* __tstate = wxPyBeginAllowThreads();
40354 result = (wxPySizer *)new wxPySizer();
40355
40356 wxPyEndAllowThreads(__tstate);
40357 if (PyErr_Occurred()) SWIG_fail;
40358 }
40359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40360 return resultobj;
40361 fail:
40362 return NULL;
40363 }
40364
40365
40366 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40367 PyObject *resultobj;
40368 wxPySizer *arg1 = (wxPySizer *) 0 ;
40369 PyObject *arg2 = (PyObject *) 0 ;
40370 PyObject *arg3 = (PyObject *) 0 ;
40371 PyObject * obj0 = 0 ;
40372 PyObject * obj1 = 0 ;
40373 PyObject * obj2 = 0 ;
40374 char *kwnames[] = {
40375 (char *) "self",(char *) "self",(char *) "_class", NULL
40376 };
40377
40378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40380 if (SWIG_arg_fail(1)) SWIG_fail;
40381 arg2 = obj1;
40382 arg3 = obj2;
40383 {
40384 PyThreadState* __tstate = wxPyBeginAllowThreads();
40385 (arg1)->_setCallbackInfo(arg2,arg3);
40386
40387 wxPyEndAllowThreads(__tstate);
40388 if (PyErr_Occurred()) SWIG_fail;
40389 }
40390 Py_INCREF(Py_None); resultobj = Py_None;
40391 return resultobj;
40392 fail:
40393 return NULL;
40394 }
40395
40396
40397 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40398 PyObject *obj;
40399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40400 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40401 Py_INCREF(obj);
40402 return Py_BuildValue((char *)"");
40403 }
40404 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40405 PyObject *resultobj;
40406 int arg1 = (int) wxHORIZONTAL ;
40407 wxBoxSizer *result;
40408 PyObject * obj0 = 0 ;
40409 char *kwnames[] = {
40410 (char *) "orient", NULL
40411 };
40412
40413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40414 if (obj0) {
40415 {
40416 arg1 = (int)(SWIG_As_int(obj0));
40417 if (SWIG_arg_fail(1)) SWIG_fail;
40418 }
40419 }
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40423
40424 wxPyEndAllowThreads(__tstate);
40425 if (PyErr_Occurred()) SWIG_fail;
40426 }
40427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40435 PyObject *resultobj;
40436 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40437 int result;
40438 PyObject * obj0 = 0 ;
40439 char *kwnames[] = {
40440 (char *) "self", NULL
40441 };
40442
40443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40445 if (SWIG_arg_fail(1)) SWIG_fail;
40446 {
40447 PyThreadState* __tstate = wxPyBeginAllowThreads();
40448 result = (int)(arg1)->GetOrientation();
40449
40450 wxPyEndAllowThreads(__tstate);
40451 if (PyErr_Occurred()) SWIG_fail;
40452 }
40453 {
40454 resultobj = SWIG_From_int((int)(result));
40455 }
40456 return resultobj;
40457 fail:
40458 return NULL;
40459 }
40460
40461
40462 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40463 PyObject *resultobj;
40464 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40465 int arg2 ;
40466 PyObject * obj0 = 0 ;
40467 PyObject * obj1 = 0 ;
40468 char *kwnames[] = {
40469 (char *) "self",(char *) "orient", NULL
40470 };
40471
40472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40474 if (SWIG_arg_fail(1)) SWIG_fail;
40475 {
40476 arg2 = (int)(SWIG_As_int(obj1));
40477 if (SWIG_arg_fail(2)) SWIG_fail;
40478 }
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 (arg1)->SetOrientation(arg2);
40482
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 Py_INCREF(Py_None); resultobj = Py_None;
40487 return resultobj;
40488 fail:
40489 return NULL;
40490 }
40491
40492
40493 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40494 PyObject *obj;
40495 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40496 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40497 Py_INCREF(obj);
40498 return Py_BuildValue((char *)"");
40499 }
40500 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40501 PyObject *resultobj;
40502 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40503 int arg2 = (int) wxHORIZONTAL ;
40504 wxStaticBoxSizer *result;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 char *kwnames[] = {
40508 (char *) "box",(char *) "orient", NULL
40509 };
40510
40511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40513 if (SWIG_arg_fail(1)) SWIG_fail;
40514 if (obj1) {
40515 {
40516 arg2 = (int)(SWIG_As_int(obj1));
40517 if (SWIG_arg_fail(2)) SWIG_fail;
40518 }
40519 }
40520 {
40521 PyThreadState* __tstate = wxPyBeginAllowThreads();
40522 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40523
40524 wxPyEndAllowThreads(__tstate);
40525 if (PyErr_Occurred()) SWIG_fail;
40526 }
40527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40528 return resultobj;
40529 fail:
40530 return NULL;
40531 }
40532
40533
40534 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40535 PyObject *resultobj;
40536 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40537 wxStaticBox *result;
40538 PyObject * obj0 = 0 ;
40539 char *kwnames[] = {
40540 (char *) "self", NULL
40541 };
40542
40543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40545 if (SWIG_arg_fail(1)) SWIG_fail;
40546 {
40547 PyThreadState* __tstate = wxPyBeginAllowThreads();
40548 result = (wxStaticBox *)(arg1)->GetStaticBox();
40549
40550 wxPyEndAllowThreads(__tstate);
40551 if (PyErr_Occurred()) SWIG_fail;
40552 }
40553 {
40554 resultobj = wxPyMake_wxObject(result, 0);
40555 }
40556 return resultobj;
40557 fail:
40558 return NULL;
40559 }
40560
40561
40562 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40563 PyObject *obj;
40564 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40565 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40566 Py_INCREF(obj);
40567 return Py_BuildValue((char *)"");
40568 }
40569 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40570 PyObject *resultobj;
40571 int arg1 = (int) 1 ;
40572 int arg2 = (int) 0 ;
40573 int arg3 = (int) 0 ;
40574 int arg4 = (int) 0 ;
40575 wxGridSizer *result;
40576 PyObject * obj0 = 0 ;
40577 PyObject * obj1 = 0 ;
40578 PyObject * obj2 = 0 ;
40579 PyObject * obj3 = 0 ;
40580 char *kwnames[] = {
40581 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40582 };
40583
40584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40585 if (obj0) {
40586 {
40587 arg1 = (int)(SWIG_As_int(obj0));
40588 if (SWIG_arg_fail(1)) SWIG_fail;
40589 }
40590 }
40591 if (obj1) {
40592 {
40593 arg2 = (int)(SWIG_As_int(obj1));
40594 if (SWIG_arg_fail(2)) SWIG_fail;
40595 }
40596 }
40597 if (obj2) {
40598 {
40599 arg3 = (int)(SWIG_As_int(obj2));
40600 if (SWIG_arg_fail(3)) SWIG_fail;
40601 }
40602 }
40603 if (obj3) {
40604 {
40605 arg4 = (int)(SWIG_As_int(obj3));
40606 if (SWIG_arg_fail(4)) SWIG_fail;
40607 }
40608 }
40609 {
40610 PyThreadState* __tstate = wxPyBeginAllowThreads();
40611 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40612
40613 wxPyEndAllowThreads(__tstate);
40614 if (PyErr_Occurred()) SWIG_fail;
40615 }
40616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40617 return resultobj;
40618 fail:
40619 return NULL;
40620 }
40621
40622
40623 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40624 PyObject *resultobj;
40625 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40626 int arg2 ;
40627 PyObject * obj0 = 0 ;
40628 PyObject * obj1 = 0 ;
40629 char *kwnames[] = {
40630 (char *) "self",(char *) "cols", NULL
40631 };
40632
40633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40635 if (SWIG_arg_fail(1)) SWIG_fail;
40636 {
40637 arg2 = (int)(SWIG_As_int(obj1));
40638 if (SWIG_arg_fail(2)) SWIG_fail;
40639 }
40640 {
40641 PyThreadState* __tstate = wxPyBeginAllowThreads();
40642 (arg1)->SetCols(arg2);
40643
40644 wxPyEndAllowThreads(__tstate);
40645 if (PyErr_Occurred()) SWIG_fail;
40646 }
40647 Py_INCREF(Py_None); resultobj = Py_None;
40648 return resultobj;
40649 fail:
40650 return NULL;
40651 }
40652
40653
40654 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40655 PyObject *resultobj;
40656 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40657 int arg2 ;
40658 PyObject * obj0 = 0 ;
40659 PyObject * obj1 = 0 ;
40660 char *kwnames[] = {
40661 (char *) "self",(char *) "rows", NULL
40662 };
40663
40664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40666 if (SWIG_arg_fail(1)) SWIG_fail;
40667 {
40668 arg2 = (int)(SWIG_As_int(obj1));
40669 if (SWIG_arg_fail(2)) SWIG_fail;
40670 }
40671 {
40672 PyThreadState* __tstate = wxPyBeginAllowThreads();
40673 (arg1)->SetRows(arg2);
40674
40675 wxPyEndAllowThreads(__tstate);
40676 if (PyErr_Occurred()) SWIG_fail;
40677 }
40678 Py_INCREF(Py_None); resultobj = Py_None;
40679 return resultobj;
40680 fail:
40681 return NULL;
40682 }
40683
40684
40685 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40686 PyObject *resultobj;
40687 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40688 int arg2 ;
40689 PyObject * obj0 = 0 ;
40690 PyObject * obj1 = 0 ;
40691 char *kwnames[] = {
40692 (char *) "self",(char *) "gap", NULL
40693 };
40694
40695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40697 if (SWIG_arg_fail(1)) SWIG_fail;
40698 {
40699 arg2 = (int)(SWIG_As_int(obj1));
40700 if (SWIG_arg_fail(2)) SWIG_fail;
40701 }
40702 {
40703 PyThreadState* __tstate = wxPyBeginAllowThreads();
40704 (arg1)->SetVGap(arg2);
40705
40706 wxPyEndAllowThreads(__tstate);
40707 if (PyErr_Occurred()) SWIG_fail;
40708 }
40709 Py_INCREF(Py_None); resultobj = Py_None;
40710 return resultobj;
40711 fail:
40712 return NULL;
40713 }
40714
40715
40716 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40717 PyObject *resultobj;
40718 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40719 int arg2 ;
40720 PyObject * obj0 = 0 ;
40721 PyObject * obj1 = 0 ;
40722 char *kwnames[] = {
40723 (char *) "self",(char *) "gap", NULL
40724 };
40725
40726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40728 if (SWIG_arg_fail(1)) SWIG_fail;
40729 {
40730 arg2 = (int)(SWIG_As_int(obj1));
40731 if (SWIG_arg_fail(2)) SWIG_fail;
40732 }
40733 {
40734 PyThreadState* __tstate = wxPyBeginAllowThreads();
40735 (arg1)->SetHGap(arg2);
40736
40737 wxPyEndAllowThreads(__tstate);
40738 if (PyErr_Occurred()) SWIG_fail;
40739 }
40740 Py_INCREF(Py_None); resultobj = Py_None;
40741 return resultobj;
40742 fail:
40743 return NULL;
40744 }
40745
40746
40747 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40748 PyObject *resultobj;
40749 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40750 int result;
40751 PyObject * obj0 = 0 ;
40752 char *kwnames[] = {
40753 (char *) "self", NULL
40754 };
40755
40756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40758 if (SWIG_arg_fail(1)) SWIG_fail;
40759 {
40760 PyThreadState* __tstate = wxPyBeginAllowThreads();
40761 result = (int)(arg1)->GetCols();
40762
40763 wxPyEndAllowThreads(__tstate);
40764 if (PyErr_Occurred()) SWIG_fail;
40765 }
40766 {
40767 resultobj = SWIG_From_int((int)(result));
40768 }
40769 return resultobj;
40770 fail:
40771 return NULL;
40772 }
40773
40774
40775 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40776 PyObject *resultobj;
40777 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40778 int result;
40779 PyObject * obj0 = 0 ;
40780 char *kwnames[] = {
40781 (char *) "self", NULL
40782 };
40783
40784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40786 if (SWIG_arg_fail(1)) SWIG_fail;
40787 {
40788 PyThreadState* __tstate = wxPyBeginAllowThreads();
40789 result = (int)(arg1)->GetRows();
40790
40791 wxPyEndAllowThreads(__tstate);
40792 if (PyErr_Occurred()) SWIG_fail;
40793 }
40794 {
40795 resultobj = SWIG_From_int((int)(result));
40796 }
40797 return resultobj;
40798 fail:
40799 return NULL;
40800 }
40801
40802
40803 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40804 PyObject *resultobj;
40805 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40806 int result;
40807 PyObject * obj0 = 0 ;
40808 char *kwnames[] = {
40809 (char *) "self", NULL
40810 };
40811
40812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40814 if (SWIG_arg_fail(1)) SWIG_fail;
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 result = (int)(arg1)->GetVGap();
40818
40819 wxPyEndAllowThreads(__tstate);
40820 if (PyErr_Occurred()) SWIG_fail;
40821 }
40822 {
40823 resultobj = SWIG_From_int((int)(result));
40824 }
40825 return resultobj;
40826 fail:
40827 return NULL;
40828 }
40829
40830
40831 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40832 PyObject *resultobj;
40833 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40834 int result;
40835 PyObject * obj0 = 0 ;
40836 char *kwnames[] = {
40837 (char *) "self", NULL
40838 };
40839
40840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40842 if (SWIG_arg_fail(1)) SWIG_fail;
40843 {
40844 PyThreadState* __tstate = wxPyBeginAllowThreads();
40845 result = (int)(arg1)->GetHGap();
40846
40847 wxPyEndAllowThreads(__tstate);
40848 if (PyErr_Occurred()) SWIG_fail;
40849 }
40850 {
40851 resultobj = SWIG_From_int((int)(result));
40852 }
40853 return resultobj;
40854 fail:
40855 return NULL;
40856 }
40857
40858
40859 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40860 PyObject *obj;
40861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40862 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40863 Py_INCREF(obj);
40864 return Py_BuildValue((char *)"");
40865 }
40866 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40867 PyObject *resultobj;
40868 int arg1 = (int) 1 ;
40869 int arg2 = (int) 0 ;
40870 int arg3 = (int) 0 ;
40871 int arg4 = (int) 0 ;
40872 wxFlexGridSizer *result;
40873 PyObject * obj0 = 0 ;
40874 PyObject * obj1 = 0 ;
40875 PyObject * obj2 = 0 ;
40876 PyObject * obj3 = 0 ;
40877 char *kwnames[] = {
40878 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40879 };
40880
40881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40882 if (obj0) {
40883 {
40884 arg1 = (int)(SWIG_As_int(obj0));
40885 if (SWIG_arg_fail(1)) SWIG_fail;
40886 }
40887 }
40888 if (obj1) {
40889 {
40890 arg2 = (int)(SWIG_As_int(obj1));
40891 if (SWIG_arg_fail(2)) SWIG_fail;
40892 }
40893 }
40894 if (obj2) {
40895 {
40896 arg3 = (int)(SWIG_As_int(obj2));
40897 if (SWIG_arg_fail(3)) SWIG_fail;
40898 }
40899 }
40900 if (obj3) {
40901 {
40902 arg4 = (int)(SWIG_As_int(obj3));
40903 if (SWIG_arg_fail(4)) SWIG_fail;
40904 }
40905 }
40906 {
40907 PyThreadState* __tstate = wxPyBeginAllowThreads();
40908 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40909
40910 wxPyEndAllowThreads(__tstate);
40911 if (PyErr_Occurred()) SWIG_fail;
40912 }
40913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj;
40922 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40923 size_t arg2 ;
40924 int arg3 = (int) 0 ;
40925 PyObject * obj0 = 0 ;
40926 PyObject * obj1 = 0 ;
40927 PyObject * obj2 = 0 ;
40928 char *kwnames[] = {
40929 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40930 };
40931
40932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40934 if (SWIG_arg_fail(1)) SWIG_fail;
40935 {
40936 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40937 if (SWIG_arg_fail(2)) SWIG_fail;
40938 }
40939 if (obj2) {
40940 {
40941 arg3 = (int)(SWIG_As_int(obj2));
40942 if (SWIG_arg_fail(3)) SWIG_fail;
40943 }
40944 }
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 (arg1)->AddGrowableRow(arg2,arg3);
40948
40949 wxPyEndAllowThreads(__tstate);
40950 if (PyErr_Occurred()) SWIG_fail;
40951 }
40952 Py_INCREF(Py_None); resultobj = Py_None;
40953 return resultobj;
40954 fail:
40955 return NULL;
40956 }
40957
40958
40959 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40960 PyObject *resultobj;
40961 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40962 size_t arg2 ;
40963 PyObject * obj0 = 0 ;
40964 PyObject * obj1 = 0 ;
40965 char *kwnames[] = {
40966 (char *) "self",(char *) "idx", NULL
40967 };
40968
40969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40971 if (SWIG_arg_fail(1)) SWIG_fail;
40972 {
40973 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40974 if (SWIG_arg_fail(2)) SWIG_fail;
40975 }
40976 {
40977 PyThreadState* __tstate = wxPyBeginAllowThreads();
40978 (arg1)->RemoveGrowableRow(arg2);
40979
40980 wxPyEndAllowThreads(__tstate);
40981 if (PyErr_Occurred()) SWIG_fail;
40982 }
40983 Py_INCREF(Py_None); resultobj = Py_None;
40984 return resultobj;
40985 fail:
40986 return NULL;
40987 }
40988
40989
40990 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40991 PyObject *resultobj;
40992 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40993 size_t arg2 ;
40994 int arg3 = (int) 0 ;
40995 PyObject * obj0 = 0 ;
40996 PyObject * obj1 = 0 ;
40997 PyObject * obj2 = 0 ;
40998 char *kwnames[] = {
40999 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41000 };
41001
41002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41004 if (SWIG_arg_fail(1)) SWIG_fail;
41005 {
41006 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41007 if (SWIG_arg_fail(2)) SWIG_fail;
41008 }
41009 if (obj2) {
41010 {
41011 arg3 = (int)(SWIG_As_int(obj2));
41012 if (SWIG_arg_fail(3)) SWIG_fail;
41013 }
41014 }
41015 {
41016 PyThreadState* __tstate = wxPyBeginAllowThreads();
41017 (arg1)->AddGrowableCol(arg2,arg3);
41018
41019 wxPyEndAllowThreads(__tstate);
41020 if (PyErr_Occurred()) SWIG_fail;
41021 }
41022 Py_INCREF(Py_None); resultobj = Py_None;
41023 return resultobj;
41024 fail:
41025 return NULL;
41026 }
41027
41028
41029 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41030 PyObject *resultobj;
41031 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41032 size_t arg2 ;
41033 PyObject * obj0 = 0 ;
41034 PyObject * obj1 = 0 ;
41035 char *kwnames[] = {
41036 (char *) "self",(char *) "idx", NULL
41037 };
41038
41039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41041 if (SWIG_arg_fail(1)) SWIG_fail;
41042 {
41043 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41044 if (SWIG_arg_fail(2)) SWIG_fail;
41045 }
41046 {
41047 PyThreadState* __tstate = wxPyBeginAllowThreads();
41048 (arg1)->RemoveGrowableCol(arg2);
41049
41050 wxPyEndAllowThreads(__tstate);
41051 if (PyErr_Occurred()) SWIG_fail;
41052 }
41053 Py_INCREF(Py_None); resultobj = Py_None;
41054 return resultobj;
41055 fail:
41056 return NULL;
41057 }
41058
41059
41060 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41061 PyObject *resultobj;
41062 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41063 int arg2 ;
41064 PyObject * obj0 = 0 ;
41065 PyObject * obj1 = 0 ;
41066 char *kwnames[] = {
41067 (char *) "self",(char *) "direction", NULL
41068 };
41069
41070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41072 if (SWIG_arg_fail(1)) SWIG_fail;
41073 {
41074 arg2 = (int)(SWIG_As_int(obj1));
41075 if (SWIG_arg_fail(2)) SWIG_fail;
41076 }
41077 {
41078 PyThreadState* __tstate = wxPyBeginAllowThreads();
41079 (arg1)->SetFlexibleDirection(arg2);
41080
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 Py_INCREF(Py_None); resultobj = Py_None;
41085 return resultobj;
41086 fail:
41087 return NULL;
41088 }
41089
41090
41091 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41092 PyObject *resultobj;
41093 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41094 int result;
41095 PyObject * obj0 = 0 ;
41096 char *kwnames[] = {
41097 (char *) "self", NULL
41098 };
41099
41100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41102 if (SWIG_arg_fail(1)) SWIG_fail;
41103 {
41104 PyThreadState* __tstate = wxPyBeginAllowThreads();
41105 result = (int)(arg1)->GetFlexibleDirection();
41106
41107 wxPyEndAllowThreads(__tstate);
41108 if (PyErr_Occurred()) SWIG_fail;
41109 }
41110 {
41111 resultobj = SWIG_From_int((int)(result));
41112 }
41113 return resultobj;
41114 fail:
41115 return NULL;
41116 }
41117
41118
41119 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj;
41121 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41122 wxFlexSizerGrowMode arg2 ;
41123 PyObject * obj0 = 0 ;
41124 PyObject * obj1 = 0 ;
41125 char *kwnames[] = {
41126 (char *) "self",(char *) "mode", NULL
41127 };
41128
41129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41131 if (SWIG_arg_fail(1)) SWIG_fail;
41132 {
41133 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41134 if (SWIG_arg_fail(2)) SWIG_fail;
41135 }
41136 {
41137 PyThreadState* __tstate = wxPyBeginAllowThreads();
41138 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41139
41140 wxPyEndAllowThreads(__tstate);
41141 if (PyErr_Occurred()) SWIG_fail;
41142 }
41143 Py_INCREF(Py_None); resultobj = Py_None;
41144 return resultobj;
41145 fail:
41146 return NULL;
41147 }
41148
41149
41150 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41151 PyObject *resultobj;
41152 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41153 wxFlexSizerGrowMode result;
41154 PyObject * obj0 = 0 ;
41155 char *kwnames[] = {
41156 (char *) "self", NULL
41157 };
41158
41159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41161 if (SWIG_arg_fail(1)) SWIG_fail;
41162 {
41163 PyThreadState* __tstate = wxPyBeginAllowThreads();
41164 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41165
41166 wxPyEndAllowThreads(__tstate);
41167 if (PyErr_Occurred()) SWIG_fail;
41168 }
41169 resultobj = SWIG_From_int((result));
41170 return resultobj;
41171 fail:
41172 return NULL;
41173 }
41174
41175
41176 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41177 PyObject *resultobj;
41178 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41179 wxArrayInt *result;
41180 PyObject * obj0 = 0 ;
41181 char *kwnames[] = {
41182 (char *) "self", NULL
41183 };
41184
41185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41187 if (SWIG_arg_fail(1)) SWIG_fail;
41188 {
41189 PyThreadState* __tstate = wxPyBeginAllowThreads();
41190 {
41191 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41192 result = (wxArrayInt *) &_result_ref;
41193 }
41194
41195 wxPyEndAllowThreads(__tstate);
41196 if (PyErr_Occurred()) SWIG_fail;
41197 }
41198 {
41199 resultobj = PyList_New(0);
41200 size_t idx;
41201 for (idx = 0; idx < result->GetCount(); idx += 1) {
41202 PyObject* val = PyInt_FromLong( result->Item(idx) );
41203 PyList_Append(resultobj, val);
41204 Py_DECREF(val);
41205 }
41206 }
41207 return resultobj;
41208 fail:
41209 return NULL;
41210 }
41211
41212
41213 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41214 PyObject *resultobj;
41215 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41216 wxArrayInt *result;
41217 PyObject * obj0 = 0 ;
41218 char *kwnames[] = {
41219 (char *) "self", NULL
41220 };
41221
41222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41224 if (SWIG_arg_fail(1)) SWIG_fail;
41225 {
41226 PyThreadState* __tstate = wxPyBeginAllowThreads();
41227 {
41228 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41229 result = (wxArrayInt *) &_result_ref;
41230 }
41231
41232 wxPyEndAllowThreads(__tstate);
41233 if (PyErr_Occurred()) SWIG_fail;
41234 }
41235 {
41236 resultobj = PyList_New(0);
41237 size_t idx;
41238 for (idx = 0; idx < result->GetCount(); idx += 1) {
41239 PyObject* val = PyInt_FromLong( result->Item(idx) );
41240 PyList_Append(resultobj, val);
41241 Py_DECREF(val);
41242 }
41243 }
41244 return resultobj;
41245 fail:
41246 return NULL;
41247 }
41248
41249
41250 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41251 PyObject *obj;
41252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41253 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41254 Py_INCREF(obj);
41255 return Py_BuildValue((char *)"");
41256 }
41257 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41258 PyObject *resultobj;
41259 wxStdDialogButtonSizer *result;
41260 char *kwnames[] = {
41261 NULL
41262 };
41263
41264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41265 {
41266 PyThreadState* __tstate = wxPyBeginAllowThreads();
41267 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41268
41269 wxPyEndAllowThreads(__tstate);
41270 if (PyErr_Occurred()) SWIG_fail;
41271 }
41272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41273 return resultobj;
41274 fail:
41275 return NULL;
41276 }
41277
41278
41279 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41280 PyObject *resultobj;
41281 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41282 wxButton *arg2 = (wxButton *) 0 ;
41283 PyObject * obj0 = 0 ;
41284 PyObject * obj1 = 0 ;
41285 char *kwnames[] = {
41286 (char *) "self",(char *) "button", NULL
41287 };
41288
41289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41291 if (SWIG_arg_fail(1)) SWIG_fail;
41292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41293 if (SWIG_arg_fail(2)) SWIG_fail;
41294 {
41295 PyThreadState* __tstate = wxPyBeginAllowThreads();
41296 (arg1)->AddButton(arg2);
41297
41298 wxPyEndAllowThreads(__tstate);
41299 if (PyErr_Occurred()) SWIG_fail;
41300 }
41301 Py_INCREF(Py_None); resultobj = Py_None;
41302 return resultobj;
41303 fail:
41304 return NULL;
41305 }
41306
41307
41308 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41309 PyObject *resultobj;
41310 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41311 PyObject * obj0 = 0 ;
41312 char *kwnames[] = {
41313 (char *) "self", NULL
41314 };
41315
41316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41318 if (SWIG_arg_fail(1)) SWIG_fail;
41319 {
41320 PyThreadState* __tstate = wxPyBeginAllowThreads();
41321 (arg1)->Realize();
41322
41323 wxPyEndAllowThreads(__tstate);
41324 if (PyErr_Occurred()) SWIG_fail;
41325 }
41326 Py_INCREF(Py_None); resultobj = Py_None;
41327 return resultobj;
41328 fail:
41329 return NULL;
41330 }
41331
41332
41333 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41334 PyObject *resultobj;
41335 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41336 wxButton *arg2 = (wxButton *) 0 ;
41337 PyObject * obj0 = 0 ;
41338 PyObject * obj1 = 0 ;
41339 char *kwnames[] = {
41340 (char *) "self",(char *) "button", NULL
41341 };
41342
41343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41345 if (SWIG_arg_fail(1)) SWIG_fail;
41346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41347 if (SWIG_arg_fail(2)) SWIG_fail;
41348 {
41349 PyThreadState* __tstate = wxPyBeginAllowThreads();
41350 (arg1)->SetAffirmativeButton(arg2);
41351
41352 wxPyEndAllowThreads(__tstate);
41353 if (PyErr_Occurred()) SWIG_fail;
41354 }
41355 Py_INCREF(Py_None); resultobj = Py_None;
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41363 PyObject *resultobj;
41364 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41365 wxButton *arg2 = (wxButton *) 0 ;
41366 PyObject * obj0 = 0 ;
41367 PyObject * obj1 = 0 ;
41368 char *kwnames[] = {
41369 (char *) "self",(char *) "button", NULL
41370 };
41371
41372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41374 if (SWIG_arg_fail(1)) SWIG_fail;
41375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41376 if (SWIG_arg_fail(2)) SWIG_fail;
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 (arg1)->SetNegativeButton(arg2);
41380
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 Py_INCREF(Py_None); resultobj = Py_None;
41385 return resultobj;
41386 fail:
41387 return NULL;
41388 }
41389
41390
41391 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41392 PyObject *resultobj;
41393 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41394 wxButton *arg2 = (wxButton *) 0 ;
41395 PyObject * obj0 = 0 ;
41396 PyObject * obj1 = 0 ;
41397 char *kwnames[] = {
41398 (char *) "self",(char *) "button", NULL
41399 };
41400
41401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41403 if (SWIG_arg_fail(1)) SWIG_fail;
41404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41405 if (SWIG_arg_fail(2)) SWIG_fail;
41406 {
41407 PyThreadState* __tstate = wxPyBeginAllowThreads();
41408 (arg1)->SetCancelButton(arg2);
41409
41410 wxPyEndAllowThreads(__tstate);
41411 if (PyErr_Occurred()) SWIG_fail;
41412 }
41413 Py_INCREF(Py_None); resultobj = Py_None;
41414 return resultobj;
41415 fail:
41416 return NULL;
41417 }
41418
41419
41420 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41421 PyObject *resultobj;
41422 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41423 wxButton *result;
41424 PyObject * obj0 = 0 ;
41425 char *kwnames[] = {
41426 (char *) "self", NULL
41427 };
41428
41429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41431 if (SWIG_arg_fail(1)) SWIG_fail;
41432 {
41433 PyThreadState* __tstate = wxPyBeginAllowThreads();
41434 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41435
41436 wxPyEndAllowThreads(__tstate);
41437 if (PyErr_Occurred()) SWIG_fail;
41438 }
41439 {
41440 resultobj = wxPyMake_wxObject(result, 0);
41441 }
41442 return resultobj;
41443 fail:
41444 return NULL;
41445 }
41446
41447
41448 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41449 PyObject *resultobj;
41450 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41451 wxButton *result;
41452 PyObject * obj0 = 0 ;
41453 char *kwnames[] = {
41454 (char *) "self", NULL
41455 };
41456
41457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41459 if (SWIG_arg_fail(1)) SWIG_fail;
41460 {
41461 PyThreadState* __tstate = wxPyBeginAllowThreads();
41462 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41463
41464 wxPyEndAllowThreads(__tstate);
41465 if (PyErr_Occurred()) SWIG_fail;
41466 }
41467 {
41468 resultobj = wxPyMake_wxObject(result, 0);
41469 }
41470 return resultobj;
41471 fail:
41472 return NULL;
41473 }
41474
41475
41476 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41477 PyObject *resultobj;
41478 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41479 wxButton *result;
41480 PyObject * obj0 = 0 ;
41481 char *kwnames[] = {
41482 (char *) "self", NULL
41483 };
41484
41485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41487 if (SWIG_arg_fail(1)) SWIG_fail;
41488 {
41489 PyThreadState* __tstate = wxPyBeginAllowThreads();
41490 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41491
41492 wxPyEndAllowThreads(__tstate);
41493 if (PyErr_Occurred()) SWIG_fail;
41494 }
41495 {
41496 resultobj = wxPyMake_wxObject(result, 0);
41497 }
41498 return resultobj;
41499 fail:
41500 return NULL;
41501 }
41502
41503
41504 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41505 PyObject *resultobj;
41506 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41507 wxButton *result;
41508 PyObject * obj0 = 0 ;
41509 char *kwnames[] = {
41510 (char *) "self", NULL
41511 };
41512
41513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41515 if (SWIG_arg_fail(1)) SWIG_fail;
41516 {
41517 PyThreadState* __tstate = wxPyBeginAllowThreads();
41518 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41519
41520 wxPyEndAllowThreads(__tstate);
41521 if (PyErr_Occurred()) SWIG_fail;
41522 }
41523 {
41524 resultobj = wxPyMake_wxObject(result, 0);
41525 }
41526 return resultobj;
41527 fail:
41528 return NULL;
41529 }
41530
41531
41532 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41533 PyObject *resultobj;
41534 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41535 wxButton *result;
41536 PyObject * obj0 = 0 ;
41537 char *kwnames[] = {
41538 (char *) "self", NULL
41539 };
41540
41541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41543 if (SWIG_arg_fail(1)) SWIG_fail;
41544 {
41545 PyThreadState* __tstate = wxPyBeginAllowThreads();
41546 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41547
41548 wxPyEndAllowThreads(__tstate);
41549 if (PyErr_Occurred()) SWIG_fail;
41550 }
41551 {
41552 resultobj = wxPyMake_wxObject(result, 0);
41553 }
41554 return resultobj;
41555 fail:
41556 return NULL;
41557 }
41558
41559
41560 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41561 PyObject *obj;
41562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41563 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41564 Py_INCREF(obj);
41565 return Py_BuildValue((char *)"");
41566 }
41567 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41568 PyObject *resultobj;
41569 int arg1 = (int) 0 ;
41570 int arg2 = (int) 0 ;
41571 wxGBPosition *result;
41572 PyObject * obj0 = 0 ;
41573 PyObject * obj1 = 0 ;
41574 char *kwnames[] = {
41575 (char *) "row",(char *) "col", NULL
41576 };
41577
41578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41579 if (obj0) {
41580 {
41581 arg1 = (int)(SWIG_As_int(obj0));
41582 if (SWIG_arg_fail(1)) SWIG_fail;
41583 }
41584 }
41585 if (obj1) {
41586 {
41587 arg2 = (int)(SWIG_As_int(obj1));
41588 if (SWIG_arg_fail(2)) SWIG_fail;
41589 }
41590 }
41591 {
41592 PyThreadState* __tstate = wxPyBeginAllowThreads();
41593 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41594
41595 wxPyEndAllowThreads(__tstate);
41596 if (PyErr_Occurred()) SWIG_fail;
41597 }
41598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41599 return resultobj;
41600 fail:
41601 return NULL;
41602 }
41603
41604
41605 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41606 PyObject *resultobj;
41607 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41608 int result;
41609 PyObject * obj0 = 0 ;
41610 char *kwnames[] = {
41611 (char *) "self", NULL
41612 };
41613
41614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41616 if (SWIG_arg_fail(1)) SWIG_fail;
41617 {
41618 PyThreadState* __tstate = wxPyBeginAllowThreads();
41619 result = (int)((wxGBPosition const *)arg1)->GetRow();
41620
41621 wxPyEndAllowThreads(__tstate);
41622 if (PyErr_Occurred()) SWIG_fail;
41623 }
41624 {
41625 resultobj = SWIG_From_int((int)(result));
41626 }
41627 return resultobj;
41628 fail:
41629 return NULL;
41630 }
41631
41632
41633 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41634 PyObject *resultobj;
41635 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41636 int result;
41637 PyObject * obj0 = 0 ;
41638 char *kwnames[] = {
41639 (char *) "self", NULL
41640 };
41641
41642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41644 if (SWIG_arg_fail(1)) SWIG_fail;
41645 {
41646 PyThreadState* __tstate = wxPyBeginAllowThreads();
41647 result = (int)((wxGBPosition const *)arg1)->GetCol();
41648
41649 wxPyEndAllowThreads(__tstate);
41650 if (PyErr_Occurred()) SWIG_fail;
41651 }
41652 {
41653 resultobj = SWIG_From_int((int)(result));
41654 }
41655 return resultobj;
41656 fail:
41657 return NULL;
41658 }
41659
41660
41661 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41662 PyObject *resultobj;
41663 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41664 int arg2 ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 char *kwnames[] = {
41668 (char *) "self",(char *) "row", NULL
41669 };
41670
41671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41673 if (SWIG_arg_fail(1)) SWIG_fail;
41674 {
41675 arg2 = (int)(SWIG_As_int(obj1));
41676 if (SWIG_arg_fail(2)) SWIG_fail;
41677 }
41678 {
41679 PyThreadState* __tstate = wxPyBeginAllowThreads();
41680 (arg1)->SetRow(arg2);
41681
41682 wxPyEndAllowThreads(__tstate);
41683 if (PyErr_Occurred()) SWIG_fail;
41684 }
41685 Py_INCREF(Py_None); resultobj = Py_None;
41686 return resultobj;
41687 fail:
41688 return NULL;
41689 }
41690
41691
41692 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41693 PyObject *resultobj;
41694 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41695 int arg2 ;
41696 PyObject * obj0 = 0 ;
41697 PyObject * obj1 = 0 ;
41698 char *kwnames[] = {
41699 (char *) "self",(char *) "col", NULL
41700 };
41701
41702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41704 if (SWIG_arg_fail(1)) SWIG_fail;
41705 {
41706 arg2 = (int)(SWIG_As_int(obj1));
41707 if (SWIG_arg_fail(2)) SWIG_fail;
41708 }
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 (arg1)->SetCol(arg2);
41712
41713 wxPyEndAllowThreads(__tstate);
41714 if (PyErr_Occurred()) SWIG_fail;
41715 }
41716 Py_INCREF(Py_None); resultobj = Py_None;
41717 return resultobj;
41718 fail:
41719 return NULL;
41720 }
41721
41722
41723 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41724 PyObject *resultobj;
41725 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41726 wxGBPosition *arg2 = 0 ;
41727 bool result;
41728 wxGBPosition temp2 ;
41729 PyObject * obj0 = 0 ;
41730 PyObject * obj1 = 0 ;
41731 char *kwnames[] = {
41732 (char *) "self",(char *) "other", NULL
41733 };
41734
41735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41737 if (SWIG_arg_fail(1)) SWIG_fail;
41738 {
41739 arg2 = &temp2;
41740 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41741 }
41742 {
41743 PyThreadState* __tstate = wxPyBeginAllowThreads();
41744 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41745
41746 wxPyEndAllowThreads(__tstate);
41747 if (PyErr_Occurred()) SWIG_fail;
41748 }
41749 {
41750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41751 }
41752 return resultobj;
41753 fail:
41754 return NULL;
41755 }
41756
41757
41758 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41759 PyObject *resultobj;
41760 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41761 wxGBPosition *arg2 = 0 ;
41762 bool result;
41763 wxGBPosition temp2 ;
41764 PyObject * obj0 = 0 ;
41765 PyObject * obj1 = 0 ;
41766 char *kwnames[] = {
41767 (char *) "self",(char *) "other", NULL
41768 };
41769
41770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41772 if (SWIG_arg_fail(1)) SWIG_fail;
41773 {
41774 arg2 = &temp2;
41775 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41776 }
41777 {
41778 PyThreadState* __tstate = wxPyBeginAllowThreads();
41779 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41780
41781 wxPyEndAllowThreads(__tstate);
41782 if (PyErr_Occurred()) SWIG_fail;
41783 }
41784 {
41785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41786 }
41787 return resultobj;
41788 fail:
41789 return NULL;
41790 }
41791
41792
41793 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41794 PyObject *resultobj;
41795 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41796 int arg2 = (int) 0 ;
41797 int arg3 = (int) 0 ;
41798 PyObject * obj0 = 0 ;
41799 PyObject * obj1 = 0 ;
41800 PyObject * obj2 = 0 ;
41801 char *kwnames[] = {
41802 (char *) "self",(char *) "row",(char *) "col", NULL
41803 };
41804
41805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41807 if (SWIG_arg_fail(1)) SWIG_fail;
41808 if (obj1) {
41809 {
41810 arg2 = (int)(SWIG_As_int(obj1));
41811 if (SWIG_arg_fail(2)) SWIG_fail;
41812 }
41813 }
41814 if (obj2) {
41815 {
41816 arg3 = (int)(SWIG_As_int(obj2));
41817 if (SWIG_arg_fail(3)) SWIG_fail;
41818 }
41819 }
41820 {
41821 PyThreadState* __tstate = wxPyBeginAllowThreads();
41822 wxGBPosition_Set(arg1,arg2,arg3);
41823
41824 wxPyEndAllowThreads(__tstate);
41825 if (PyErr_Occurred()) SWIG_fail;
41826 }
41827 Py_INCREF(Py_None); resultobj = Py_None;
41828 return resultobj;
41829 fail:
41830 return NULL;
41831 }
41832
41833
41834 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41835 PyObject *resultobj;
41836 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41837 PyObject *result;
41838 PyObject * obj0 = 0 ;
41839 char *kwnames[] = {
41840 (char *) "self", NULL
41841 };
41842
41843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41845 if (SWIG_arg_fail(1)) SWIG_fail;
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 result = (PyObject *)wxGBPosition_Get(arg1);
41849
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 resultobj = result;
41854 return resultobj;
41855 fail:
41856 return NULL;
41857 }
41858
41859
41860 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41861 PyObject *obj;
41862 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41863 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41864 Py_INCREF(obj);
41865 return Py_BuildValue((char *)"");
41866 }
41867 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41868 PyObject *resultobj;
41869 int arg1 = (int) 1 ;
41870 int arg2 = (int) 1 ;
41871 wxGBSpan *result;
41872 PyObject * obj0 = 0 ;
41873 PyObject * obj1 = 0 ;
41874 char *kwnames[] = {
41875 (char *) "rowspan",(char *) "colspan", NULL
41876 };
41877
41878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41879 if (obj0) {
41880 {
41881 arg1 = (int)(SWIG_As_int(obj0));
41882 if (SWIG_arg_fail(1)) SWIG_fail;
41883 }
41884 }
41885 if (obj1) {
41886 {
41887 arg2 = (int)(SWIG_As_int(obj1));
41888 if (SWIG_arg_fail(2)) SWIG_fail;
41889 }
41890 }
41891 {
41892 PyThreadState* __tstate = wxPyBeginAllowThreads();
41893 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41894
41895 wxPyEndAllowThreads(__tstate);
41896 if (PyErr_Occurred()) SWIG_fail;
41897 }
41898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41899 return resultobj;
41900 fail:
41901 return NULL;
41902 }
41903
41904
41905 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41906 PyObject *resultobj;
41907 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41908 int result;
41909 PyObject * obj0 = 0 ;
41910 char *kwnames[] = {
41911 (char *) "self", NULL
41912 };
41913
41914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41916 if (SWIG_arg_fail(1)) SWIG_fail;
41917 {
41918 PyThreadState* __tstate = wxPyBeginAllowThreads();
41919 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41920
41921 wxPyEndAllowThreads(__tstate);
41922 if (PyErr_Occurred()) SWIG_fail;
41923 }
41924 {
41925 resultobj = SWIG_From_int((int)(result));
41926 }
41927 return resultobj;
41928 fail:
41929 return NULL;
41930 }
41931
41932
41933 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41934 PyObject *resultobj;
41935 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41936 int result;
41937 PyObject * obj0 = 0 ;
41938 char *kwnames[] = {
41939 (char *) "self", NULL
41940 };
41941
41942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41944 if (SWIG_arg_fail(1)) SWIG_fail;
41945 {
41946 PyThreadState* __tstate = wxPyBeginAllowThreads();
41947 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41948
41949 wxPyEndAllowThreads(__tstate);
41950 if (PyErr_Occurred()) SWIG_fail;
41951 }
41952 {
41953 resultobj = SWIG_From_int((int)(result));
41954 }
41955 return resultobj;
41956 fail:
41957 return NULL;
41958 }
41959
41960
41961 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41962 PyObject *resultobj;
41963 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41964 int arg2 ;
41965 PyObject * obj0 = 0 ;
41966 PyObject * obj1 = 0 ;
41967 char *kwnames[] = {
41968 (char *) "self",(char *) "rowspan", NULL
41969 };
41970
41971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41973 if (SWIG_arg_fail(1)) SWIG_fail;
41974 {
41975 arg2 = (int)(SWIG_As_int(obj1));
41976 if (SWIG_arg_fail(2)) SWIG_fail;
41977 }
41978 {
41979 PyThreadState* __tstate = wxPyBeginAllowThreads();
41980 (arg1)->SetRowspan(arg2);
41981
41982 wxPyEndAllowThreads(__tstate);
41983 if (PyErr_Occurred()) SWIG_fail;
41984 }
41985 Py_INCREF(Py_None); resultobj = Py_None;
41986 return resultobj;
41987 fail:
41988 return NULL;
41989 }
41990
41991
41992 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41993 PyObject *resultobj;
41994 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41995 int arg2 ;
41996 PyObject * obj0 = 0 ;
41997 PyObject * obj1 = 0 ;
41998 char *kwnames[] = {
41999 (char *) "self",(char *) "colspan", NULL
42000 };
42001
42002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42004 if (SWIG_arg_fail(1)) SWIG_fail;
42005 {
42006 arg2 = (int)(SWIG_As_int(obj1));
42007 if (SWIG_arg_fail(2)) SWIG_fail;
42008 }
42009 {
42010 PyThreadState* __tstate = wxPyBeginAllowThreads();
42011 (arg1)->SetColspan(arg2);
42012
42013 wxPyEndAllowThreads(__tstate);
42014 if (PyErr_Occurred()) SWIG_fail;
42015 }
42016 Py_INCREF(Py_None); resultobj = Py_None;
42017 return resultobj;
42018 fail:
42019 return NULL;
42020 }
42021
42022
42023 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42024 PyObject *resultobj;
42025 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42026 wxGBSpan *arg2 = 0 ;
42027 bool result;
42028 wxGBSpan temp2 ;
42029 PyObject * obj0 = 0 ;
42030 PyObject * obj1 = 0 ;
42031 char *kwnames[] = {
42032 (char *) "self",(char *) "other", NULL
42033 };
42034
42035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42037 if (SWIG_arg_fail(1)) SWIG_fail;
42038 {
42039 arg2 = &temp2;
42040 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42041 }
42042 {
42043 PyThreadState* __tstate = wxPyBeginAllowThreads();
42044 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42045
42046 wxPyEndAllowThreads(__tstate);
42047 if (PyErr_Occurred()) SWIG_fail;
42048 }
42049 {
42050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42051 }
42052 return resultobj;
42053 fail:
42054 return NULL;
42055 }
42056
42057
42058 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42059 PyObject *resultobj;
42060 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42061 wxGBSpan *arg2 = 0 ;
42062 bool result;
42063 wxGBSpan temp2 ;
42064 PyObject * obj0 = 0 ;
42065 PyObject * obj1 = 0 ;
42066 char *kwnames[] = {
42067 (char *) "self",(char *) "other", NULL
42068 };
42069
42070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42072 if (SWIG_arg_fail(1)) SWIG_fail;
42073 {
42074 arg2 = &temp2;
42075 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42076 }
42077 {
42078 PyThreadState* __tstate = wxPyBeginAllowThreads();
42079 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42080
42081 wxPyEndAllowThreads(__tstate);
42082 if (PyErr_Occurred()) SWIG_fail;
42083 }
42084 {
42085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42086 }
42087 return resultobj;
42088 fail:
42089 return NULL;
42090 }
42091
42092
42093 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42094 PyObject *resultobj;
42095 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42096 int arg2 = (int) 1 ;
42097 int arg3 = (int) 1 ;
42098 PyObject * obj0 = 0 ;
42099 PyObject * obj1 = 0 ;
42100 PyObject * obj2 = 0 ;
42101 char *kwnames[] = {
42102 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42103 };
42104
42105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42107 if (SWIG_arg_fail(1)) SWIG_fail;
42108 if (obj1) {
42109 {
42110 arg2 = (int)(SWIG_As_int(obj1));
42111 if (SWIG_arg_fail(2)) SWIG_fail;
42112 }
42113 }
42114 if (obj2) {
42115 {
42116 arg3 = (int)(SWIG_As_int(obj2));
42117 if (SWIG_arg_fail(3)) SWIG_fail;
42118 }
42119 }
42120 {
42121 PyThreadState* __tstate = wxPyBeginAllowThreads();
42122 wxGBSpan_Set(arg1,arg2,arg3);
42123
42124 wxPyEndAllowThreads(__tstate);
42125 if (PyErr_Occurred()) SWIG_fail;
42126 }
42127 Py_INCREF(Py_None); resultobj = Py_None;
42128 return resultobj;
42129 fail:
42130 return NULL;
42131 }
42132
42133
42134 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42135 PyObject *resultobj;
42136 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42137 PyObject *result;
42138 PyObject * obj0 = 0 ;
42139 char *kwnames[] = {
42140 (char *) "self", NULL
42141 };
42142
42143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42145 if (SWIG_arg_fail(1)) SWIG_fail;
42146 {
42147 PyThreadState* __tstate = wxPyBeginAllowThreads();
42148 result = (PyObject *)wxGBSpan_Get(arg1);
42149
42150 wxPyEndAllowThreads(__tstate);
42151 if (PyErr_Occurred()) SWIG_fail;
42152 }
42153 resultobj = result;
42154 return resultobj;
42155 fail:
42156 return NULL;
42157 }
42158
42159
42160 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42161 PyObject *obj;
42162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42163 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42164 Py_INCREF(obj);
42165 return Py_BuildValue((char *)"");
42166 }
42167 static int _wrap_DefaultSpan_set(PyObject *) {
42168 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42169 return 1;
42170 }
42171
42172
42173 static PyObject *_wrap_DefaultSpan_get(void) {
42174 PyObject *pyobj;
42175
42176 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42177 return pyobj;
42178 }
42179
42180
42181 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42182 PyObject *resultobj;
42183 wxGBSizerItem *result;
42184 char *kwnames[] = {
42185 NULL
42186 };
42187
42188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42189 {
42190 PyThreadState* __tstate = wxPyBeginAllowThreads();
42191 result = (wxGBSizerItem *)new wxGBSizerItem();
42192
42193 wxPyEndAllowThreads(__tstate);
42194 if (PyErr_Occurred()) SWIG_fail;
42195 }
42196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42197 return resultobj;
42198 fail:
42199 return NULL;
42200 }
42201
42202
42203 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42204 PyObject *resultobj;
42205 wxWindow *arg1 = (wxWindow *) 0 ;
42206 wxGBPosition *arg2 = 0 ;
42207 wxGBSpan *arg3 = 0 ;
42208 int arg4 ;
42209 int arg5 ;
42210 PyObject *arg6 = (PyObject *) NULL ;
42211 wxGBSizerItem *result;
42212 wxGBPosition temp2 ;
42213 wxGBSpan temp3 ;
42214 PyObject * obj0 = 0 ;
42215 PyObject * obj1 = 0 ;
42216 PyObject * obj2 = 0 ;
42217 PyObject * obj3 = 0 ;
42218 PyObject * obj4 = 0 ;
42219 PyObject * obj5 = 0 ;
42220 char *kwnames[] = {
42221 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42222 };
42223
42224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42226 if (SWIG_arg_fail(1)) SWIG_fail;
42227 {
42228 arg2 = &temp2;
42229 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42230 }
42231 {
42232 arg3 = &temp3;
42233 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42234 }
42235 {
42236 arg4 = (int)(SWIG_As_int(obj3));
42237 if (SWIG_arg_fail(4)) SWIG_fail;
42238 }
42239 {
42240 arg5 = (int)(SWIG_As_int(obj4));
42241 if (SWIG_arg_fail(5)) SWIG_fail;
42242 }
42243 if (obj5) {
42244 arg6 = obj5;
42245 }
42246 {
42247 PyThreadState* __tstate = wxPyBeginAllowThreads();
42248 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42249
42250 wxPyEndAllowThreads(__tstate);
42251 if (PyErr_Occurred()) SWIG_fail;
42252 }
42253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42254 return resultobj;
42255 fail:
42256 return NULL;
42257 }
42258
42259
42260 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42261 PyObject *resultobj;
42262 wxSizer *arg1 = (wxSizer *) 0 ;
42263 wxGBPosition *arg2 = 0 ;
42264 wxGBSpan *arg3 = 0 ;
42265 int arg4 ;
42266 int arg5 ;
42267 PyObject *arg6 = (PyObject *) NULL ;
42268 wxGBSizerItem *result;
42269 wxGBPosition temp2 ;
42270 wxGBSpan temp3 ;
42271 PyObject * obj0 = 0 ;
42272 PyObject * obj1 = 0 ;
42273 PyObject * obj2 = 0 ;
42274 PyObject * obj3 = 0 ;
42275 PyObject * obj4 = 0 ;
42276 PyObject * obj5 = 0 ;
42277 char *kwnames[] = {
42278 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42279 };
42280
42281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42283 if (SWIG_arg_fail(1)) SWIG_fail;
42284 {
42285 arg2 = &temp2;
42286 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42287 }
42288 {
42289 arg3 = &temp3;
42290 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42291 }
42292 {
42293 arg4 = (int)(SWIG_As_int(obj3));
42294 if (SWIG_arg_fail(4)) SWIG_fail;
42295 }
42296 {
42297 arg5 = (int)(SWIG_As_int(obj4));
42298 if (SWIG_arg_fail(5)) SWIG_fail;
42299 }
42300 if (obj5) {
42301 arg6 = obj5;
42302 }
42303 {
42304 PyThreadState* __tstate = wxPyBeginAllowThreads();
42305 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42306
42307 wxPyEndAllowThreads(__tstate);
42308 if (PyErr_Occurred()) SWIG_fail;
42309 }
42310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42311 return resultobj;
42312 fail:
42313 return NULL;
42314 }
42315
42316
42317 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42318 PyObject *resultobj;
42319 int arg1 ;
42320 int arg2 ;
42321 wxGBPosition *arg3 = 0 ;
42322 wxGBSpan *arg4 = 0 ;
42323 int arg5 ;
42324 int arg6 ;
42325 PyObject *arg7 = (PyObject *) NULL ;
42326 wxGBSizerItem *result;
42327 wxGBPosition temp3 ;
42328 wxGBSpan temp4 ;
42329 PyObject * obj0 = 0 ;
42330 PyObject * obj1 = 0 ;
42331 PyObject * obj2 = 0 ;
42332 PyObject * obj3 = 0 ;
42333 PyObject * obj4 = 0 ;
42334 PyObject * obj5 = 0 ;
42335 PyObject * obj6 = 0 ;
42336 char *kwnames[] = {
42337 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42338 };
42339
42340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42341 {
42342 arg1 = (int)(SWIG_As_int(obj0));
42343 if (SWIG_arg_fail(1)) SWIG_fail;
42344 }
42345 {
42346 arg2 = (int)(SWIG_As_int(obj1));
42347 if (SWIG_arg_fail(2)) SWIG_fail;
42348 }
42349 {
42350 arg3 = &temp3;
42351 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42352 }
42353 {
42354 arg4 = &temp4;
42355 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42356 }
42357 {
42358 arg5 = (int)(SWIG_As_int(obj4));
42359 if (SWIG_arg_fail(5)) SWIG_fail;
42360 }
42361 {
42362 arg6 = (int)(SWIG_As_int(obj5));
42363 if (SWIG_arg_fail(6)) SWIG_fail;
42364 }
42365 if (obj6) {
42366 arg7 = obj6;
42367 }
42368 {
42369 PyThreadState* __tstate = wxPyBeginAllowThreads();
42370 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42371
42372 wxPyEndAllowThreads(__tstate);
42373 if (PyErr_Occurred()) SWIG_fail;
42374 }
42375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42376 return resultobj;
42377 fail:
42378 return NULL;
42379 }
42380
42381
42382 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42383 PyObject *resultobj;
42384 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42385 wxGBPosition result;
42386 PyObject * obj0 = 0 ;
42387 char *kwnames[] = {
42388 (char *) "self", NULL
42389 };
42390
42391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42393 if (SWIG_arg_fail(1)) SWIG_fail;
42394 {
42395 PyThreadState* __tstate = wxPyBeginAllowThreads();
42396 result = ((wxGBSizerItem const *)arg1)->GetPos();
42397
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 {
42402 wxGBPosition * resultptr;
42403 resultptr = new wxGBPosition((wxGBPosition &)(result));
42404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42405 }
42406 return resultobj;
42407 fail:
42408 return NULL;
42409 }
42410
42411
42412 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42413 PyObject *resultobj;
42414 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42415 wxGBSpan result;
42416 PyObject * obj0 = 0 ;
42417 char *kwnames[] = {
42418 (char *) "self", NULL
42419 };
42420
42421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42423 if (SWIG_arg_fail(1)) SWIG_fail;
42424 {
42425 PyThreadState* __tstate = wxPyBeginAllowThreads();
42426 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42427
42428 wxPyEndAllowThreads(__tstate);
42429 if (PyErr_Occurred()) SWIG_fail;
42430 }
42431 {
42432 wxGBSpan * resultptr;
42433 resultptr = new wxGBSpan((wxGBSpan &)(result));
42434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42435 }
42436 return resultobj;
42437 fail:
42438 return NULL;
42439 }
42440
42441
42442 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42443 PyObject *resultobj;
42444 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42445 wxGBPosition *arg2 = 0 ;
42446 bool result;
42447 wxGBPosition temp2 ;
42448 PyObject * obj0 = 0 ;
42449 PyObject * obj1 = 0 ;
42450 char *kwnames[] = {
42451 (char *) "self",(char *) "pos", NULL
42452 };
42453
42454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42456 if (SWIG_arg_fail(1)) SWIG_fail;
42457 {
42458 arg2 = &temp2;
42459 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42460 }
42461 {
42462 PyThreadState* __tstate = wxPyBeginAllowThreads();
42463 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42464
42465 wxPyEndAllowThreads(__tstate);
42466 if (PyErr_Occurred()) SWIG_fail;
42467 }
42468 {
42469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42470 }
42471 return resultobj;
42472 fail:
42473 return NULL;
42474 }
42475
42476
42477 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42478 PyObject *resultobj;
42479 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42480 wxGBSpan *arg2 = 0 ;
42481 bool result;
42482 wxGBSpan temp2 ;
42483 PyObject * obj0 = 0 ;
42484 PyObject * obj1 = 0 ;
42485 char *kwnames[] = {
42486 (char *) "self",(char *) "span", NULL
42487 };
42488
42489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42491 if (SWIG_arg_fail(1)) SWIG_fail;
42492 {
42493 arg2 = &temp2;
42494 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42495 }
42496 {
42497 PyThreadState* __tstate = wxPyBeginAllowThreads();
42498 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42499
42500 wxPyEndAllowThreads(__tstate);
42501 if (PyErr_Occurred()) SWIG_fail;
42502 }
42503 {
42504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42505 }
42506 return resultobj;
42507 fail:
42508 return NULL;
42509 }
42510
42511
42512 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42513 PyObject *resultobj;
42514 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42515 wxGBSizerItem *arg2 = 0 ;
42516 bool result;
42517 PyObject * obj0 = 0 ;
42518 PyObject * obj1 = 0 ;
42519 char *kwnames[] = {
42520 (char *) "self",(char *) "other", NULL
42521 };
42522
42523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42525 if (SWIG_arg_fail(1)) SWIG_fail;
42526 {
42527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42528 if (SWIG_arg_fail(2)) SWIG_fail;
42529 if (arg2 == NULL) {
42530 SWIG_null_ref("wxGBSizerItem");
42531 }
42532 if (SWIG_arg_fail(2)) SWIG_fail;
42533 }
42534 {
42535 PyThreadState* __tstate = wxPyBeginAllowThreads();
42536 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42537
42538 wxPyEndAllowThreads(__tstate);
42539 if (PyErr_Occurred()) SWIG_fail;
42540 }
42541 {
42542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42543 }
42544 return resultobj;
42545 fail:
42546 return NULL;
42547 }
42548
42549
42550 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42551 PyObject *resultobj;
42552 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42553 wxGBPosition *arg2 = 0 ;
42554 wxGBSpan *arg3 = 0 ;
42555 bool result;
42556 wxGBPosition temp2 ;
42557 wxGBSpan temp3 ;
42558 PyObject * obj0 = 0 ;
42559 PyObject * obj1 = 0 ;
42560 PyObject * obj2 = 0 ;
42561 char *kwnames[] = {
42562 (char *) "self",(char *) "pos",(char *) "span", NULL
42563 };
42564
42565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42567 if (SWIG_arg_fail(1)) SWIG_fail;
42568 {
42569 arg2 = &temp2;
42570 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42571 }
42572 {
42573 arg3 = &temp3;
42574 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42575 }
42576 {
42577 PyThreadState* __tstate = wxPyBeginAllowThreads();
42578 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42579
42580 wxPyEndAllowThreads(__tstate);
42581 if (PyErr_Occurred()) SWIG_fail;
42582 }
42583 {
42584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42585 }
42586 return resultobj;
42587 fail:
42588 return NULL;
42589 }
42590
42591
42592 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42593 PyObject *resultobj;
42594 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42595 wxGBPosition result;
42596 PyObject * obj0 = 0 ;
42597 char *kwnames[] = {
42598 (char *) "self", NULL
42599 };
42600
42601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42603 if (SWIG_arg_fail(1)) SWIG_fail;
42604 {
42605 PyThreadState* __tstate = wxPyBeginAllowThreads();
42606 result = wxGBSizerItem_GetEndPos(arg1);
42607
42608 wxPyEndAllowThreads(__tstate);
42609 if (PyErr_Occurred()) SWIG_fail;
42610 }
42611 {
42612 wxGBPosition * resultptr;
42613 resultptr = new wxGBPosition((wxGBPosition &)(result));
42614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42615 }
42616 return resultobj;
42617 fail:
42618 return NULL;
42619 }
42620
42621
42622 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42623 PyObject *resultobj;
42624 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42625 wxGridBagSizer *result;
42626 PyObject * obj0 = 0 ;
42627 char *kwnames[] = {
42628 (char *) "self", NULL
42629 };
42630
42631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42633 if (SWIG_arg_fail(1)) SWIG_fail;
42634 {
42635 PyThreadState* __tstate = wxPyBeginAllowThreads();
42636 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42637
42638 wxPyEndAllowThreads(__tstate);
42639 if (PyErr_Occurred()) SWIG_fail;
42640 }
42641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42642 return resultobj;
42643 fail:
42644 return NULL;
42645 }
42646
42647
42648 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42649 PyObject *resultobj;
42650 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42651 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42652 PyObject * obj0 = 0 ;
42653 PyObject * obj1 = 0 ;
42654 char *kwnames[] = {
42655 (char *) "self",(char *) "sizer", NULL
42656 };
42657
42658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42660 if (SWIG_arg_fail(1)) SWIG_fail;
42661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42662 if (SWIG_arg_fail(2)) SWIG_fail;
42663 {
42664 PyThreadState* __tstate = wxPyBeginAllowThreads();
42665 (arg1)->SetGBSizer(arg2);
42666
42667 wxPyEndAllowThreads(__tstate);
42668 if (PyErr_Occurred()) SWIG_fail;
42669 }
42670 Py_INCREF(Py_None); resultobj = Py_None;
42671 return resultobj;
42672 fail:
42673 return NULL;
42674 }
42675
42676
42677 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42678 PyObject *obj;
42679 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42680 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42681 Py_INCREF(obj);
42682 return Py_BuildValue((char *)"");
42683 }
42684 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42685 PyObject *resultobj;
42686 int arg1 = (int) 0 ;
42687 int arg2 = (int) 0 ;
42688 wxGridBagSizer *result;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691 char *kwnames[] = {
42692 (char *) "vgap",(char *) "hgap", NULL
42693 };
42694
42695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42696 if (obj0) {
42697 {
42698 arg1 = (int)(SWIG_As_int(obj0));
42699 if (SWIG_arg_fail(1)) SWIG_fail;
42700 }
42701 }
42702 if (obj1) {
42703 {
42704 arg2 = (int)(SWIG_As_int(obj1));
42705 if (SWIG_arg_fail(2)) SWIG_fail;
42706 }
42707 }
42708 {
42709 PyThreadState* __tstate = wxPyBeginAllowThreads();
42710 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42711
42712 wxPyEndAllowThreads(__tstate);
42713 if (PyErr_Occurred()) SWIG_fail;
42714 }
42715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42716 return resultobj;
42717 fail:
42718 return NULL;
42719 }
42720
42721
42722 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42723 PyObject *resultobj;
42724 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42725 PyObject *arg2 = (PyObject *) 0 ;
42726 wxGBPosition *arg3 = 0 ;
42727 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42728 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42729 int arg5 = (int) 0 ;
42730 int arg6 = (int) 0 ;
42731 PyObject *arg7 = (PyObject *) NULL ;
42732 wxGBSizerItem *result;
42733 wxGBPosition temp3 ;
42734 wxGBSpan temp4 ;
42735 PyObject * obj0 = 0 ;
42736 PyObject * obj1 = 0 ;
42737 PyObject * obj2 = 0 ;
42738 PyObject * obj3 = 0 ;
42739 PyObject * obj4 = 0 ;
42740 PyObject * obj5 = 0 ;
42741 PyObject * obj6 = 0 ;
42742 char *kwnames[] = {
42743 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42744 };
42745
42746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42748 if (SWIG_arg_fail(1)) SWIG_fail;
42749 arg2 = obj1;
42750 {
42751 arg3 = &temp3;
42752 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42753 }
42754 if (obj3) {
42755 {
42756 arg4 = &temp4;
42757 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42758 }
42759 }
42760 if (obj4) {
42761 {
42762 arg5 = (int)(SWIG_As_int(obj4));
42763 if (SWIG_arg_fail(5)) SWIG_fail;
42764 }
42765 }
42766 if (obj5) {
42767 {
42768 arg6 = (int)(SWIG_As_int(obj5));
42769 if (SWIG_arg_fail(6)) SWIG_fail;
42770 }
42771 }
42772 if (obj6) {
42773 arg7 = obj6;
42774 }
42775 {
42776 PyThreadState* __tstate = wxPyBeginAllowThreads();
42777 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42778
42779 wxPyEndAllowThreads(__tstate);
42780 if (PyErr_Occurred()) SWIG_fail;
42781 }
42782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42783 return resultobj;
42784 fail:
42785 return NULL;
42786 }
42787
42788
42789 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42790 PyObject *resultobj;
42791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42792 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42793 wxGBSizerItem *result;
42794 PyObject * obj0 = 0 ;
42795 PyObject * obj1 = 0 ;
42796 char *kwnames[] = {
42797 (char *) "self",(char *) "item", NULL
42798 };
42799
42800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42802 if (SWIG_arg_fail(1)) SWIG_fail;
42803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42804 if (SWIG_arg_fail(2)) SWIG_fail;
42805 {
42806 PyThreadState* __tstate = wxPyBeginAllowThreads();
42807 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42808
42809 wxPyEndAllowThreads(__tstate);
42810 if (PyErr_Occurred()) SWIG_fail;
42811 }
42812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42813 return resultobj;
42814 fail:
42815 return NULL;
42816 }
42817
42818
42819 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42820 PyObject *resultobj;
42821 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42822 int arg2 ;
42823 int arg3 ;
42824 wxSize result;
42825 PyObject * obj0 = 0 ;
42826 PyObject * obj1 = 0 ;
42827 PyObject * obj2 = 0 ;
42828 char *kwnames[] = {
42829 (char *) "self",(char *) "row",(char *) "col", NULL
42830 };
42831
42832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42834 if (SWIG_arg_fail(1)) SWIG_fail;
42835 {
42836 arg2 = (int)(SWIG_As_int(obj1));
42837 if (SWIG_arg_fail(2)) SWIG_fail;
42838 }
42839 {
42840 arg3 = (int)(SWIG_As_int(obj2));
42841 if (SWIG_arg_fail(3)) SWIG_fail;
42842 }
42843 {
42844 PyThreadState* __tstate = wxPyBeginAllowThreads();
42845 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42846
42847 wxPyEndAllowThreads(__tstate);
42848 if (PyErr_Occurred()) SWIG_fail;
42849 }
42850 {
42851 wxSize * resultptr;
42852 resultptr = new wxSize((wxSize &)(result));
42853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42854 }
42855 return resultobj;
42856 fail:
42857 return NULL;
42858 }
42859
42860
42861 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42862 PyObject *resultobj;
42863 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42864 wxSize result;
42865 PyObject * obj0 = 0 ;
42866 char *kwnames[] = {
42867 (char *) "self", NULL
42868 };
42869
42870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42872 if (SWIG_arg_fail(1)) SWIG_fail;
42873 {
42874 PyThreadState* __tstate = wxPyBeginAllowThreads();
42875 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42876
42877 wxPyEndAllowThreads(__tstate);
42878 if (PyErr_Occurred()) SWIG_fail;
42879 }
42880 {
42881 wxSize * resultptr;
42882 resultptr = new wxSize((wxSize &)(result));
42883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42884 }
42885 return resultobj;
42886 fail:
42887 return NULL;
42888 }
42889
42890
42891 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42892 PyObject *resultobj;
42893 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42894 wxSize *arg2 = 0 ;
42895 wxSize temp2 ;
42896 PyObject * obj0 = 0 ;
42897 PyObject * obj1 = 0 ;
42898 char *kwnames[] = {
42899 (char *) "self",(char *) "sz", NULL
42900 };
42901
42902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42904 if (SWIG_arg_fail(1)) SWIG_fail;
42905 {
42906 arg2 = &temp2;
42907 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42908 }
42909 {
42910 PyThreadState* __tstate = wxPyBeginAllowThreads();
42911 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42912
42913 wxPyEndAllowThreads(__tstate);
42914 if (PyErr_Occurred()) SWIG_fail;
42915 }
42916 Py_INCREF(Py_None); resultobj = Py_None;
42917 return resultobj;
42918 fail:
42919 return NULL;
42920 }
42921
42922
42923 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42924 PyObject *resultobj;
42925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42926 wxWindow *arg2 = (wxWindow *) 0 ;
42927 wxGBPosition result;
42928 PyObject * obj0 = 0 ;
42929 PyObject * obj1 = 0 ;
42930
42931 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42933 if (SWIG_arg_fail(1)) SWIG_fail;
42934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42935 if (SWIG_arg_fail(2)) SWIG_fail;
42936 {
42937 PyThreadState* __tstate = wxPyBeginAllowThreads();
42938 result = (arg1)->GetItemPosition(arg2);
42939
42940 wxPyEndAllowThreads(__tstate);
42941 if (PyErr_Occurred()) SWIG_fail;
42942 }
42943 {
42944 wxGBPosition * resultptr;
42945 resultptr = new wxGBPosition((wxGBPosition &)(result));
42946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42947 }
42948 return resultobj;
42949 fail:
42950 return NULL;
42951 }
42952
42953
42954 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42955 PyObject *resultobj;
42956 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42957 wxSizer *arg2 = (wxSizer *) 0 ;
42958 wxGBPosition result;
42959 PyObject * obj0 = 0 ;
42960 PyObject * obj1 = 0 ;
42961
42962 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42964 if (SWIG_arg_fail(1)) SWIG_fail;
42965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42966 if (SWIG_arg_fail(2)) SWIG_fail;
42967 {
42968 PyThreadState* __tstate = wxPyBeginAllowThreads();
42969 result = (arg1)->GetItemPosition(arg2);
42970
42971 wxPyEndAllowThreads(__tstate);
42972 if (PyErr_Occurred()) SWIG_fail;
42973 }
42974 {
42975 wxGBPosition * resultptr;
42976 resultptr = new wxGBPosition((wxGBPosition &)(result));
42977 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42978 }
42979 return resultobj;
42980 fail:
42981 return NULL;
42982 }
42983
42984
42985 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42986 PyObject *resultobj;
42987 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42988 size_t arg2 ;
42989 wxGBPosition result;
42990 PyObject * obj0 = 0 ;
42991 PyObject * obj1 = 0 ;
42992
42993 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42995 if (SWIG_arg_fail(1)) SWIG_fail;
42996 {
42997 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42998 if (SWIG_arg_fail(2)) SWIG_fail;
42999 }
43000 {
43001 PyThreadState* __tstate = wxPyBeginAllowThreads();
43002 result = (arg1)->GetItemPosition(arg2);
43003
43004 wxPyEndAllowThreads(__tstate);
43005 if (PyErr_Occurred()) SWIG_fail;
43006 }
43007 {
43008 wxGBPosition * resultptr;
43009 resultptr = new wxGBPosition((wxGBPosition &)(result));
43010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43011 }
43012 return resultobj;
43013 fail:
43014 return NULL;
43015 }
43016
43017
43018 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43019 int argc;
43020 PyObject *argv[3];
43021 int ii;
43022
43023 argc = PyObject_Length(args);
43024 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43025 argv[ii] = PyTuple_GetItem(args,ii);
43026 }
43027 if (argc == 2) {
43028 int _v;
43029 {
43030 void *ptr;
43031 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43032 _v = 0;
43033 PyErr_Clear();
43034 } else {
43035 _v = 1;
43036 }
43037 }
43038 if (_v) {
43039 {
43040 void *ptr;
43041 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43042 _v = 0;
43043 PyErr_Clear();
43044 } else {
43045 _v = 1;
43046 }
43047 }
43048 if (_v) {
43049 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43050 }
43051 }
43052 }
43053 if (argc == 2) {
43054 int _v;
43055 {
43056 void *ptr;
43057 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43058 _v = 0;
43059 PyErr_Clear();
43060 } else {
43061 _v = 1;
43062 }
43063 }
43064 if (_v) {
43065 {
43066 void *ptr;
43067 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43068 _v = 0;
43069 PyErr_Clear();
43070 } else {
43071 _v = 1;
43072 }
43073 }
43074 if (_v) {
43075 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43076 }
43077 }
43078 }
43079 if (argc == 2) {
43080 int _v;
43081 {
43082 void *ptr;
43083 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43084 _v = 0;
43085 PyErr_Clear();
43086 } else {
43087 _v = 1;
43088 }
43089 }
43090 if (_v) {
43091 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43092 if (_v) {
43093 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43094 }
43095 }
43096 }
43097
43098 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43099 return NULL;
43100 }
43101
43102
43103 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43104 PyObject *resultobj;
43105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43106 wxWindow *arg2 = (wxWindow *) 0 ;
43107 wxGBPosition *arg3 = 0 ;
43108 bool result;
43109 wxGBPosition temp3 ;
43110 PyObject * obj0 = 0 ;
43111 PyObject * obj1 = 0 ;
43112 PyObject * obj2 = 0 ;
43113
43114 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43116 if (SWIG_arg_fail(1)) SWIG_fail;
43117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43118 if (SWIG_arg_fail(2)) SWIG_fail;
43119 {
43120 arg3 = &temp3;
43121 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43122 }
43123 {
43124 PyThreadState* __tstate = wxPyBeginAllowThreads();
43125 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43126
43127 wxPyEndAllowThreads(__tstate);
43128 if (PyErr_Occurred()) SWIG_fail;
43129 }
43130 {
43131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43132 }
43133 return resultobj;
43134 fail:
43135 return NULL;
43136 }
43137
43138
43139 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43140 PyObject *resultobj;
43141 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43142 wxSizer *arg2 = (wxSizer *) 0 ;
43143 wxGBPosition *arg3 = 0 ;
43144 bool result;
43145 wxGBPosition temp3 ;
43146 PyObject * obj0 = 0 ;
43147 PyObject * obj1 = 0 ;
43148 PyObject * obj2 = 0 ;
43149
43150 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43152 if (SWIG_arg_fail(1)) SWIG_fail;
43153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43154 if (SWIG_arg_fail(2)) SWIG_fail;
43155 {
43156 arg3 = &temp3;
43157 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43158 }
43159 {
43160 PyThreadState* __tstate = wxPyBeginAllowThreads();
43161 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43162
43163 wxPyEndAllowThreads(__tstate);
43164 if (PyErr_Occurred()) SWIG_fail;
43165 }
43166 {
43167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43168 }
43169 return resultobj;
43170 fail:
43171 return NULL;
43172 }
43173
43174
43175 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43176 PyObject *resultobj;
43177 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43178 size_t arg2 ;
43179 wxGBPosition *arg3 = 0 ;
43180 bool result;
43181 wxGBPosition temp3 ;
43182 PyObject * obj0 = 0 ;
43183 PyObject * obj1 = 0 ;
43184 PyObject * obj2 = 0 ;
43185
43186 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43188 if (SWIG_arg_fail(1)) SWIG_fail;
43189 {
43190 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43191 if (SWIG_arg_fail(2)) SWIG_fail;
43192 }
43193 {
43194 arg3 = &temp3;
43195 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43196 }
43197 {
43198 PyThreadState* __tstate = wxPyBeginAllowThreads();
43199 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43200
43201 wxPyEndAllowThreads(__tstate);
43202 if (PyErr_Occurred()) SWIG_fail;
43203 }
43204 {
43205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43206 }
43207 return resultobj;
43208 fail:
43209 return NULL;
43210 }
43211
43212
43213 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43214 int argc;
43215 PyObject *argv[4];
43216 int ii;
43217
43218 argc = PyObject_Length(args);
43219 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43220 argv[ii] = PyTuple_GetItem(args,ii);
43221 }
43222 if (argc == 3) {
43223 int _v;
43224 {
43225 void *ptr;
43226 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43227 _v = 0;
43228 PyErr_Clear();
43229 } else {
43230 _v = 1;
43231 }
43232 }
43233 if (_v) {
43234 {
43235 void *ptr;
43236 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43237 _v = 0;
43238 PyErr_Clear();
43239 } else {
43240 _v = 1;
43241 }
43242 }
43243 if (_v) {
43244 {
43245 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43246 }
43247 if (_v) {
43248 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43249 }
43250 }
43251 }
43252 }
43253 if (argc == 3) {
43254 int _v;
43255 {
43256 void *ptr;
43257 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43258 _v = 0;
43259 PyErr_Clear();
43260 } else {
43261 _v = 1;
43262 }
43263 }
43264 if (_v) {
43265 {
43266 void *ptr;
43267 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43268 _v = 0;
43269 PyErr_Clear();
43270 } else {
43271 _v = 1;
43272 }
43273 }
43274 if (_v) {
43275 {
43276 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43277 }
43278 if (_v) {
43279 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43280 }
43281 }
43282 }
43283 }
43284 if (argc == 3) {
43285 int _v;
43286 {
43287 void *ptr;
43288 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43289 _v = 0;
43290 PyErr_Clear();
43291 } else {
43292 _v = 1;
43293 }
43294 }
43295 if (_v) {
43296 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43297 if (_v) {
43298 {
43299 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43300 }
43301 if (_v) {
43302 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43303 }
43304 }
43305 }
43306 }
43307
43308 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43309 return NULL;
43310 }
43311
43312
43313 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43314 PyObject *resultobj;
43315 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43316 wxWindow *arg2 = (wxWindow *) 0 ;
43317 wxGBSpan result;
43318 PyObject * obj0 = 0 ;
43319 PyObject * obj1 = 0 ;
43320
43321 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43323 if (SWIG_arg_fail(1)) SWIG_fail;
43324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43325 if (SWIG_arg_fail(2)) SWIG_fail;
43326 {
43327 PyThreadState* __tstate = wxPyBeginAllowThreads();
43328 result = (arg1)->GetItemSpan(arg2);
43329
43330 wxPyEndAllowThreads(__tstate);
43331 if (PyErr_Occurred()) SWIG_fail;
43332 }
43333 {
43334 wxGBSpan * resultptr;
43335 resultptr = new wxGBSpan((wxGBSpan &)(result));
43336 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43337 }
43338 return resultobj;
43339 fail:
43340 return NULL;
43341 }
43342
43343
43344 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43345 PyObject *resultobj;
43346 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43347 wxSizer *arg2 = (wxSizer *) 0 ;
43348 wxGBSpan result;
43349 PyObject * obj0 = 0 ;
43350 PyObject * obj1 = 0 ;
43351
43352 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43354 if (SWIG_arg_fail(1)) SWIG_fail;
43355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43356 if (SWIG_arg_fail(2)) SWIG_fail;
43357 {
43358 PyThreadState* __tstate = wxPyBeginAllowThreads();
43359 result = (arg1)->GetItemSpan(arg2);
43360
43361 wxPyEndAllowThreads(__tstate);
43362 if (PyErr_Occurred()) SWIG_fail;
43363 }
43364 {
43365 wxGBSpan * resultptr;
43366 resultptr = new wxGBSpan((wxGBSpan &)(result));
43367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43368 }
43369 return resultobj;
43370 fail:
43371 return NULL;
43372 }
43373
43374
43375 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43376 PyObject *resultobj;
43377 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43378 size_t arg2 ;
43379 wxGBSpan result;
43380 PyObject * obj0 = 0 ;
43381 PyObject * obj1 = 0 ;
43382
43383 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43385 if (SWIG_arg_fail(1)) SWIG_fail;
43386 {
43387 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43388 if (SWIG_arg_fail(2)) SWIG_fail;
43389 }
43390 {
43391 PyThreadState* __tstate = wxPyBeginAllowThreads();
43392 result = (arg1)->GetItemSpan(arg2);
43393
43394 wxPyEndAllowThreads(__tstate);
43395 if (PyErr_Occurred()) SWIG_fail;
43396 }
43397 {
43398 wxGBSpan * resultptr;
43399 resultptr = new wxGBSpan((wxGBSpan &)(result));
43400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43401 }
43402 return resultobj;
43403 fail:
43404 return NULL;
43405 }
43406
43407
43408 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43409 int argc;
43410 PyObject *argv[3];
43411 int ii;
43412
43413 argc = PyObject_Length(args);
43414 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43415 argv[ii] = PyTuple_GetItem(args,ii);
43416 }
43417 if (argc == 2) {
43418 int _v;
43419 {
43420 void *ptr;
43421 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43422 _v = 0;
43423 PyErr_Clear();
43424 } else {
43425 _v = 1;
43426 }
43427 }
43428 if (_v) {
43429 {
43430 void *ptr;
43431 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43432 _v = 0;
43433 PyErr_Clear();
43434 } else {
43435 _v = 1;
43436 }
43437 }
43438 if (_v) {
43439 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43440 }
43441 }
43442 }
43443 if (argc == 2) {
43444 int _v;
43445 {
43446 void *ptr;
43447 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43448 _v = 0;
43449 PyErr_Clear();
43450 } else {
43451 _v = 1;
43452 }
43453 }
43454 if (_v) {
43455 {
43456 void *ptr;
43457 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43458 _v = 0;
43459 PyErr_Clear();
43460 } else {
43461 _v = 1;
43462 }
43463 }
43464 if (_v) {
43465 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43466 }
43467 }
43468 }
43469 if (argc == 2) {
43470 int _v;
43471 {
43472 void *ptr;
43473 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43474 _v = 0;
43475 PyErr_Clear();
43476 } else {
43477 _v = 1;
43478 }
43479 }
43480 if (_v) {
43481 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43482 if (_v) {
43483 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43484 }
43485 }
43486 }
43487
43488 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43489 return NULL;
43490 }
43491
43492
43493 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43494 PyObject *resultobj;
43495 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43496 wxWindow *arg2 = (wxWindow *) 0 ;
43497 wxGBSpan *arg3 = 0 ;
43498 bool result;
43499 wxGBSpan temp3 ;
43500 PyObject * obj0 = 0 ;
43501 PyObject * obj1 = 0 ;
43502 PyObject * obj2 = 0 ;
43503
43504 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43506 if (SWIG_arg_fail(1)) SWIG_fail;
43507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43508 if (SWIG_arg_fail(2)) SWIG_fail;
43509 {
43510 arg3 = &temp3;
43511 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43512 }
43513 {
43514 PyThreadState* __tstate = wxPyBeginAllowThreads();
43515 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43516
43517 wxPyEndAllowThreads(__tstate);
43518 if (PyErr_Occurred()) SWIG_fail;
43519 }
43520 {
43521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43522 }
43523 return resultobj;
43524 fail:
43525 return NULL;
43526 }
43527
43528
43529 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43530 PyObject *resultobj;
43531 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43532 wxSizer *arg2 = (wxSizer *) 0 ;
43533 wxGBSpan *arg3 = 0 ;
43534 bool result;
43535 wxGBSpan temp3 ;
43536 PyObject * obj0 = 0 ;
43537 PyObject * obj1 = 0 ;
43538 PyObject * obj2 = 0 ;
43539
43540 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43542 if (SWIG_arg_fail(1)) SWIG_fail;
43543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43544 if (SWIG_arg_fail(2)) SWIG_fail;
43545 {
43546 arg3 = &temp3;
43547 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43548 }
43549 {
43550 PyThreadState* __tstate = wxPyBeginAllowThreads();
43551 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43552
43553 wxPyEndAllowThreads(__tstate);
43554 if (PyErr_Occurred()) SWIG_fail;
43555 }
43556 {
43557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43558 }
43559 return resultobj;
43560 fail:
43561 return NULL;
43562 }
43563
43564
43565 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43566 PyObject *resultobj;
43567 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43568 size_t arg2 ;
43569 wxGBSpan *arg3 = 0 ;
43570 bool result;
43571 wxGBSpan temp3 ;
43572 PyObject * obj0 = 0 ;
43573 PyObject * obj1 = 0 ;
43574 PyObject * obj2 = 0 ;
43575
43576 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43578 if (SWIG_arg_fail(1)) SWIG_fail;
43579 {
43580 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43581 if (SWIG_arg_fail(2)) SWIG_fail;
43582 }
43583 {
43584 arg3 = &temp3;
43585 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43586 }
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43590
43591 wxPyEndAllowThreads(__tstate);
43592 if (PyErr_Occurred()) SWIG_fail;
43593 }
43594 {
43595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43596 }
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43604 int argc;
43605 PyObject *argv[4];
43606 int ii;
43607
43608 argc = PyObject_Length(args);
43609 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43610 argv[ii] = PyTuple_GetItem(args,ii);
43611 }
43612 if (argc == 3) {
43613 int _v;
43614 {
43615 void *ptr;
43616 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43617 _v = 0;
43618 PyErr_Clear();
43619 } else {
43620 _v = 1;
43621 }
43622 }
43623 if (_v) {
43624 {
43625 void *ptr;
43626 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43627 _v = 0;
43628 PyErr_Clear();
43629 } else {
43630 _v = 1;
43631 }
43632 }
43633 if (_v) {
43634 {
43635 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43636 }
43637 if (_v) {
43638 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43639 }
43640 }
43641 }
43642 }
43643 if (argc == 3) {
43644 int _v;
43645 {
43646 void *ptr;
43647 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43648 _v = 0;
43649 PyErr_Clear();
43650 } else {
43651 _v = 1;
43652 }
43653 }
43654 if (_v) {
43655 {
43656 void *ptr;
43657 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43658 _v = 0;
43659 PyErr_Clear();
43660 } else {
43661 _v = 1;
43662 }
43663 }
43664 if (_v) {
43665 {
43666 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43667 }
43668 if (_v) {
43669 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43670 }
43671 }
43672 }
43673 }
43674 if (argc == 3) {
43675 int _v;
43676 {
43677 void *ptr;
43678 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43679 _v = 0;
43680 PyErr_Clear();
43681 } else {
43682 _v = 1;
43683 }
43684 }
43685 if (_v) {
43686 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43687 if (_v) {
43688 {
43689 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43690 }
43691 if (_v) {
43692 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43693 }
43694 }
43695 }
43696 }
43697
43698 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43699 return NULL;
43700 }
43701
43702
43703 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43704 PyObject *resultobj;
43705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43706 wxWindow *arg2 = (wxWindow *) 0 ;
43707 wxGBSizerItem *result;
43708 PyObject * obj0 = 0 ;
43709 PyObject * obj1 = 0 ;
43710
43711 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43713 if (SWIG_arg_fail(1)) SWIG_fail;
43714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43715 if (SWIG_arg_fail(2)) SWIG_fail;
43716 {
43717 PyThreadState* __tstate = wxPyBeginAllowThreads();
43718 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43719
43720 wxPyEndAllowThreads(__tstate);
43721 if (PyErr_Occurred()) SWIG_fail;
43722 }
43723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43724 return resultobj;
43725 fail:
43726 return NULL;
43727 }
43728
43729
43730 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43731 PyObject *resultobj;
43732 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43733 wxSizer *arg2 = (wxSizer *) 0 ;
43734 wxGBSizerItem *result;
43735 PyObject * obj0 = 0 ;
43736 PyObject * obj1 = 0 ;
43737
43738 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43740 if (SWIG_arg_fail(1)) SWIG_fail;
43741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43742 if (SWIG_arg_fail(2)) SWIG_fail;
43743 {
43744 PyThreadState* __tstate = wxPyBeginAllowThreads();
43745 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43746
43747 wxPyEndAllowThreads(__tstate);
43748 if (PyErr_Occurred()) SWIG_fail;
43749 }
43750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43751 return resultobj;
43752 fail:
43753 return NULL;
43754 }
43755
43756
43757 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43758 int argc;
43759 PyObject *argv[3];
43760 int ii;
43761
43762 argc = PyObject_Length(args);
43763 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43764 argv[ii] = PyTuple_GetItem(args,ii);
43765 }
43766 if (argc == 2) {
43767 int _v;
43768 {
43769 void *ptr;
43770 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43771 _v = 0;
43772 PyErr_Clear();
43773 } else {
43774 _v = 1;
43775 }
43776 }
43777 if (_v) {
43778 {
43779 void *ptr;
43780 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43781 _v = 0;
43782 PyErr_Clear();
43783 } else {
43784 _v = 1;
43785 }
43786 }
43787 if (_v) {
43788 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43789 }
43790 }
43791 }
43792 if (argc == 2) {
43793 int _v;
43794 {
43795 void *ptr;
43796 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43797 _v = 0;
43798 PyErr_Clear();
43799 } else {
43800 _v = 1;
43801 }
43802 }
43803 if (_v) {
43804 {
43805 void *ptr;
43806 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43807 _v = 0;
43808 PyErr_Clear();
43809 } else {
43810 _v = 1;
43811 }
43812 }
43813 if (_v) {
43814 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43815 }
43816 }
43817 }
43818
43819 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43820 return NULL;
43821 }
43822
43823
43824 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43825 PyObject *resultobj;
43826 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43827 wxGBPosition *arg2 = 0 ;
43828 wxGBSizerItem *result;
43829 wxGBPosition temp2 ;
43830 PyObject * obj0 = 0 ;
43831 PyObject * obj1 = 0 ;
43832 char *kwnames[] = {
43833 (char *) "self",(char *) "pos", NULL
43834 };
43835
43836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43838 if (SWIG_arg_fail(1)) SWIG_fail;
43839 {
43840 arg2 = &temp2;
43841 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43842 }
43843 {
43844 PyThreadState* __tstate = wxPyBeginAllowThreads();
43845 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43846
43847 wxPyEndAllowThreads(__tstate);
43848 if (PyErr_Occurred()) SWIG_fail;
43849 }
43850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43851 return resultobj;
43852 fail:
43853 return NULL;
43854 }
43855
43856
43857 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43858 PyObject *resultobj;
43859 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43860 wxPoint *arg2 = 0 ;
43861 wxGBSizerItem *result;
43862 wxPoint temp2 ;
43863 PyObject * obj0 = 0 ;
43864 PyObject * obj1 = 0 ;
43865 char *kwnames[] = {
43866 (char *) "self",(char *) "pt", NULL
43867 };
43868
43869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43871 if (SWIG_arg_fail(1)) SWIG_fail;
43872 {
43873 arg2 = &temp2;
43874 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43875 }
43876 {
43877 PyThreadState* __tstate = wxPyBeginAllowThreads();
43878 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43879
43880 wxPyEndAllowThreads(__tstate);
43881 if (PyErr_Occurred()) SWIG_fail;
43882 }
43883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43884 return resultobj;
43885 fail:
43886 return NULL;
43887 }
43888
43889
43890 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43891 PyObject *resultobj;
43892 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43893 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43894 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43895 bool result;
43896 PyObject * obj0 = 0 ;
43897 PyObject * obj1 = 0 ;
43898 PyObject * obj2 = 0 ;
43899 char *kwnames[] = {
43900 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43901 };
43902
43903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43905 if (SWIG_arg_fail(1)) SWIG_fail;
43906 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43907 if (SWIG_arg_fail(2)) SWIG_fail;
43908 if (obj2) {
43909 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43910 if (SWIG_arg_fail(3)) SWIG_fail;
43911 }
43912 {
43913 PyThreadState* __tstate = wxPyBeginAllowThreads();
43914 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43915
43916 wxPyEndAllowThreads(__tstate);
43917 if (PyErr_Occurred()) SWIG_fail;
43918 }
43919 {
43920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43921 }
43922 return resultobj;
43923 fail:
43924 return NULL;
43925 }
43926
43927
43928 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43929 PyObject *resultobj;
43930 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43931 wxGBPosition *arg2 = 0 ;
43932 wxGBSpan *arg3 = 0 ;
43933 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43934 bool result;
43935 wxGBPosition temp2 ;
43936 wxGBSpan temp3 ;
43937 PyObject * obj0 = 0 ;
43938 PyObject * obj1 = 0 ;
43939 PyObject * obj2 = 0 ;
43940 PyObject * obj3 = 0 ;
43941 char *kwnames[] = {
43942 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43943 };
43944
43945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43947 if (SWIG_arg_fail(1)) SWIG_fail;
43948 {
43949 arg2 = &temp2;
43950 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43951 }
43952 {
43953 arg3 = &temp3;
43954 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43955 }
43956 if (obj3) {
43957 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43958 if (SWIG_arg_fail(4)) SWIG_fail;
43959 }
43960 {
43961 PyThreadState* __tstate = wxPyBeginAllowThreads();
43962 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43963
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 {
43968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43969 }
43970 return resultobj;
43971 fail:
43972 return NULL;
43973 }
43974
43975
43976 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43977 PyObject *obj;
43978 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43979 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43980 Py_INCREF(obj);
43981 return Py_BuildValue((char *)"");
43982 }
43983 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43984 PyObject *resultobj;
43985 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43986 wxRelationship arg2 ;
43987 wxWindow *arg3 = (wxWindow *) 0 ;
43988 wxEdge arg4 ;
43989 int arg5 = (int) 0 ;
43990 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43991 PyObject * obj0 = 0 ;
43992 PyObject * obj1 = 0 ;
43993 PyObject * obj2 = 0 ;
43994 PyObject * obj3 = 0 ;
43995 PyObject * obj4 = 0 ;
43996 PyObject * obj5 = 0 ;
43997 char *kwnames[] = {
43998 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43999 };
44000
44001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44003 if (SWIG_arg_fail(1)) SWIG_fail;
44004 {
44005 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44006 if (SWIG_arg_fail(2)) SWIG_fail;
44007 }
44008 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44009 if (SWIG_arg_fail(3)) SWIG_fail;
44010 {
44011 arg4 = (wxEdge)(SWIG_As_int(obj3));
44012 if (SWIG_arg_fail(4)) SWIG_fail;
44013 }
44014 if (obj4) {
44015 {
44016 arg5 = (int)(SWIG_As_int(obj4));
44017 if (SWIG_arg_fail(5)) SWIG_fail;
44018 }
44019 }
44020 if (obj5) {
44021 {
44022 arg6 = (int)(SWIG_As_int(obj5));
44023 if (SWIG_arg_fail(6)) SWIG_fail;
44024 }
44025 }
44026 {
44027 PyThreadState* __tstate = wxPyBeginAllowThreads();
44028 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44029
44030 wxPyEndAllowThreads(__tstate);
44031 if (PyErr_Occurred()) SWIG_fail;
44032 }
44033 Py_INCREF(Py_None); resultobj = Py_None;
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44041 PyObject *resultobj;
44042 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44043 wxWindow *arg2 = (wxWindow *) 0 ;
44044 int arg3 = (int) 0 ;
44045 PyObject * obj0 = 0 ;
44046 PyObject * obj1 = 0 ;
44047 PyObject * obj2 = 0 ;
44048 char *kwnames[] = {
44049 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44050 };
44051
44052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44054 if (SWIG_arg_fail(1)) SWIG_fail;
44055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44056 if (SWIG_arg_fail(2)) SWIG_fail;
44057 if (obj2) {
44058 {
44059 arg3 = (int)(SWIG_As_int(obj2));
44060 if (SWIG_arg_fail(3)) SWIG_fail;
44061 }
44062 }
44063 {
44064 PyThreadState* __tstate = wxPyBeginAllowThreads();
44065 (arg1)->LeftOf(arg2,arg3);
44066
44067 wxPyEndAllowThreads(__tstate);
44068 if (PyErr_Occurred()) SWIG_fail;
44069 }
44070 Py_INCREF(Py_None); resultobj = Py_None;
44071 return resultobj;
44072 fail:
44073 return NULL;
44074 }
44075
44076
44077 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44078 PyObject *resultobj;
44079 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44080 wxWindow *arg2 = (wxWindow *) 0 ;
44081 int arg3 = (int) 0 ;
44082 PyObject * obj0 = 0 ;
44083 PyObject * obj1 = 0 ;
44084 PyObject * obj2 = 0 ;
44085 char *kwnames[] = {
44086 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44087 };
44088
44089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44091 if (SWIG_arg_fail(1)) SWIG_fail;
44092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44093 if (SWIG_arg_fail(2)) SWIG_fail;
44094 if (obj2) {
44095 {
44096 arg3 = (int)(SWIG_As_int(obj2));
44097 if (SWIG_arg_fail(3)) SWIG_fail;
44098 }
44099 }
44100 {
44101 PyThreadState* __tstate = wxPyBeginAllowThreads();
44102 (arg1)->RightOf(arg2,arg3);
44103
44104 wxPyEndAllowThreads(__tstate);
44105 if (PyErr_Occurred()) SWIG_fail;
44106 }
44107 Py_INCREF(Py_None); resultobj = Py_None;
44108 return resultobj;
44109 fail:
44110 return NULL;
44111 }
44112
44113
44114 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44115 PyObject *resultobj;
44116 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44117 wxWindow *arg2 = (wxWindow *) 0 ;
44118 int arg3 = (int) 0 ;
44119 PyObject * obj0 = 0 ;
44120 PyObject * obj1 = 0 ;
44121 PyObject * obj2 = 0 ;
44122 char *kwnames[] = {
44123 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44124 };
44125
44126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44128 if (SWIG_arg_fail(1)) SWIG_fail;
44129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44130 if (SWIG_arg_fail(2)) SWIG_fail;
44131 if (obj2) {
44132 {
44133 arg3 = (int)(SWIG_As_int(obj2));
44134 if (SWIG_arg_fail(3)) SWIG_fail;
44135 }
44136 }
44137 {
44138 PyThreadState* __tstate = wxPyBeginAllowThreads();
44139 (arg1)->Above(arg2,arg3);
44140
44141 wxPyEndAllowThreads(__tstate);
44142 if (PyErr_Occurred()) SWIG_fail;
44143 }
44144 Py_INCREF(Py_None); resultobj = Py_None;
44145 return resultobj;
44146 fail:
44147 return NULL;
44148 }
44149
44150
44151 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44152 PyObject *resultobj;
44153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44154 wxWindow *arg2 = (wxWindow *) 0 ;
44155 int arg3 = (int) 0 ;
44156 PyObject * obj0 = 0 ;
44157 PyObject * obj1 = 0 ;
44158 PyObject * obj2 = 0 ;
44159 char *kwnames[] = {
44160 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44161 };
44162
44163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44165 if (SWIG_arg_fail(1)) SWIG_fail;
44166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44167 if (SWIG_arg_fail(2)) SWIG_fail;
44168 if (obj2) {
44169 {
44170 arg3 = (int)(SWIG_As_int(obj2));
44171 if (SWIG_arg_fail(3)) SWIG_fail;
44172 }
44173 }
44174 {
44175 PyThreadState* __tstate = wxPyBeginAllowThreads();
44176 (arg1)->Below(arg2,arg3);
44177
44178 wxPyEndAllowThreads(__tstate);
44179 if (PyErr_Occurred()) SWIG_fail;
44180 }
44181 Py_INCREF(Py_None); resultobj = Py_None;
44182 return resultobj;
44183 fail:
44184 return NULL;
44185 }
44186
44187
44188 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44189 PyObject *resultobj;
44190 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44191 wxWindow *arg2 = (wxWindow *) 0 ;
44192 wxEdge arg3 ;
44193 int arg4 = (int) 0 ;
44194 PyObject * obj0 = 0 ;
44195 PyObject * obj1 = 0 ;
44196 PyObject * obj2 = 0 ;
44197 PyObject * obj3 = 0 ;
44198 char *kwnames[] = {
44199 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44200 };
44201
44202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44204 if (SWIG_arg_fail(1)) SWIG_fail;
44205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44206 if (SWIG_arg_fail(2)) SWIG_fail;
44207 {
44208 arg3 = (wxEdge)(SWIG_As_int(obj2));
44209 if (SWIG_arg_fail(3)) SWIG_fail;
44210 }
44211 if (obj3) {
44212 {
44213 arg4 = (int)(SWIG_As_int(obj3));
44214 if (SWIG_arg_fail(4)) SWIG_fail;
44215 }
44216 }
44217 {
44218 PyThreadState* __tstate = wxPyBeginAllowThreads();
44219 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44220
44221 wxPyEndAllowThreads(__tstate);
44222 if (PyErr_Occurred()) SWIG_fail;
44223 }
44224 Py_INCREF(Py_None); resultobj = Py_None;
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44232 PyObject *resultobj;
44233 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44234 wxWindow *arg2 = (wxWindow *) 0 ;
44235 wxEdge arg3 ;
44236 int arg4 ;
44237 PyObject * obj0 = 0 ;
44238 PyObject * obj1 = 0 ;
44239 PyObject * obj2 = 0 ;
44240 PyObject * obj3 = 0 ;
44241 char *kwnames[] = {
44242 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44243 };
44244
44245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44247 if (SWIG_arg_fail(1)) SWIG_fail;
44248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44249 if (SWIG_arg_fail(2)) SWIG_fail;
44250 {
44251 arg3 = (wxEdge)(SWIG_As_int(obj2));
44252 if (SWIG_arg_fail(3)) SWIG_fail;
44253 }
44254 {
44255 arg4 = (int)(SWIG_As_int(obj3));
44256 if (SWIG_arg_fail(4)) SWIG_fail;
44257 }
44258 {
44259 PyThreadState* __tstate = wxPyBeginAllowThreads();
44260 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44261
44262 wxPyEndAllowThreads(__tstate);
44263 if (PyErr_Occurred()) SWIG_fail;
44264 }
44265 Py_INCREF(Py_None); resultobj = Py_None;
44266 return resultobj;
44267 fail:
44268 return NULL;
44269 }
44270
44271
44272 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44273 PyObject *resultobj;
44274 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44275 int arg2 ;
44276 PyObject * obj0 = 0 ;
44277 PyObject * obj1 = 0 ;
44278 char *kwnames[] = {
44279 (char *) "self",(char *) "val", NULL
44280 };
44281
44282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44284 if (SWIG_arg_fail(1)) SWIG_fail;
44285 {
44286 arg2 = (int)(SWIG_As_int(obj1));
44287 if (SWIG_arg_fail(2)) SWIG_fail;
44288 }
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 (arg1)->Absolute(arg2);
44292
44293 wxPyEndAllowThreads(__tstate);
44294 if (PyErr_Occurred()) SWIG_fail;
44295 }
44296 Py_INCREF(Py_None); resultobj = Py_None;
44297 return resultobj;
44298 fail:
44299 return NULL;
44300 }
44301
44302
44303 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44304 PyObject *resultobj;
44305 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44306 PyObject * obj0 = 0 ;
44307 char *kwnames[] = {
44308 (char *) "self", NULL
44309 };
44310
44311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44313 if (SWIG_arg_fail(1)) SWIG_fail;
44314 {
44315 PyThreadState* __tstate = wxPyBeginAllowThreads();
44316 (arg1)->Unconstrained();
44317
44318 wxPyEndAllowThreads(__tstate);
44319 if (PyErr_Occurred()) SWIG_fail;
44320 }
44321 Py_INCREF(Py_None); resultobj = Py_None;
44322 return resultobj;
44323 fail:
44324 return NULL;
44325 }
44326
44327
44328 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44329 PyObject *resultobj;
44330 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44331 PyObject * obj0 = 0 ;
44332 char *kwnames[] = {
44333 (char *) "self", NULL
44334 };
44335
44336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44338 if (SWIG_arg_fail(1)) SWIG_fail;
44339 {
44340 PyThreadState* __tstate = wxPyBeginAllowThreads();
44341 (arg1)->AsIs();
44342
44343 wxPyEndAllowThreads(__tstate);
44344 if (PyErr_Occurred()) SWIG_fail;
44345 }
44346 Py_INCREF(Py_None); resultobj = Py_None;
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44354 PyObject *resultobj;
44355 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44356 wxWindow *result;
44357 PyObject * obj0 = 0 ;
44358 char *kwnames[] = {
44359 (char *) "self", NULL
44360 };
44361
44362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44364 if (SWIG_arg_fail(1)) SWIG_fail;
44365 {
44366 PyThreadState* __tstate = wxPyBeginAllowThreads();
44367 result = (wxWindow *)(arg1)->GetOtherWindow();
44368
44369 wxPyEndAllowThreads(__tstate);
44370 if (PyErr_Occurred()) SWIG_fail;
44371 }
44372 {
44373 resultobj = wxPyMake_wxObject(result, 0);
44374 }
44375 return resultobj;
44376 fail:
44377 return NULL;
44378 }
44379
44380
44381 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44382 PyObject *resultobj;
44383 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44384 wxEdge result;
44385 PyObject * obj0 = 0 ;
44386 char *kwnames[] = {
44387 (char *) "self", NULL
44388 };
44389
44390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44392 if (SWIG_arg_fail(1)) SWIG_fail;
44393 {
44394 PyThreadState* __tstate = wxPyBeginAllowThreads();
44395 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44396
44397 wxPyEndAllowThreads(__tstate);
44398 if (PyErr_Occurred()) SWIG_fail;
44399 }
44400 resultobj = SWIG_From_int((result));
44401 return resultobj;
44402 fail:
44403 return NULL;
44404 }
44405
44406
44407 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44408 PyObject *resultobj;
44409 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44410 wxEdge arg2 ;
44411 PyObject * obj0 = 0 ;
44412 PyObject * obj1 = 0 ;
44413 char *kwnames[] = {
44414 (char *) "self",(char *) "which", NULL
44415 };
44416
44417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44419 if (SWIG_arg_fail(1)) SWIG_fail;
44420 {
44421 arg2 = (wxEdge)(SWIG_As_int(obj1));
44422 if (SWIG_arg_fail(2)) SWIG_fail;
44423 }
44424 {
44425 PyThreadState* __tstate = wxPyBeginAllowThreads();
44426 (arg1)->SetEdge((wxEdge )arg2);
44427
44428 wxPyEndAllowThreads(__tstate);
44429 if (PyErr_Occurred()) SWIG_fail;
44430 }
44431 Py_INCREF(Py_None); resultobj = Py_None;
44432 return resultobj;
44433 fail:
44434 return NULL;
44435 }
44436
44437
44438 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44439 PyObject *resultobj;
44440 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44441 int arg2 ;
44442 PyObject * obj0 = 0 ;
44443 PyObject * obj1 = 0 ;
44444 char *kwnames[] = {
44445 (char *) "self",(char *) "v", NULL
44446 };
44447
44448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44450 if (SWIG_arg_fail(1)) SWIG_fail;
44451 {
44452 arg2 = (int)(SWIG_As_int(obj1));
44453 if (SWIG_arg_fail(2)) SWIG_fail;
44454 }
44455 {
44456 PyThreadState* __tstate = wxPyBeginAllowThreads();
44457 (arg1)->SetValue(arg2);
44458
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 Py_INCREF(Py_None); resultobj = Py_None;
44463 return resultobj;
44464 fail:
44465 return NULL;
44466 }
44467
44468
44469 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44470 PyObject *resultobj;
44471 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44472 int result;
44473 PyObject * obj0 = 0 ;
44474 char *kwnames[] = {
44475 (char *) "self", NULL
44476 };
44477
44478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44480 if (SWIG_arg_fail(1)) SWIG_fail;
44481 {
44482 PyThreadState* __tstate = wxPyBeginAllowThreads();
44483 result = (int)(arg1)->GetMargin();
44484
44485 wxPyEndAllowThreads(__tstate);
44486 if (PyErr_Occurred()) SWIG_fail;
44487 }
44488 {
44489 resultobj = SWIG_From_int((int)(result));
44490 }
44491 return resultobj;
44492 fail:
44493 return NULL;
44494 }
44495
44496
44497 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44498 PyObject *resultobj;
44499 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44500 int arg2 ;
44501 PyObject * obj0 = 0 ;
44502 PyObject * obj1 = 0 ;
44503 char *kwnames[] = {
44504 (char *) "self",(char *) "m", NULL
44505 };
44506
44507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44509 if (SWIG_arg_fail(1)) SWIG_fail;
44510 {
44511 arg2 = (int)(SWIG_As_int(obj1));
44512 if (SWIG_arg_fail(2)) SWIG_fail;
44513 }
44514 {
44515 PyThreadState* __tstate = wxPyBeginAllowThreads();
44516 (arg1)->SetMargin(arg2);
44517
44518 wxPyEndAllowThreads(__tstate);
44519 if (PyErr_Occurred()) SWIG_fail;
44520 }
44521 Py_INCREF(Py_None); resultobj = Py_None;
44522 return resultobj;
44523 fail:
44524 return NULL;
44525 }
44526
44527
44528 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44529 PyObject *resultobj;
44530 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44531 int result;
44532 PyObject * obj0 = 0 ;
44533 char *kwnames[] = {
44534 (char *) "self", NULL
44535 };
44536
44537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44539 if (SWIG_arg_fail(1)) SWIG_fail;
44540 {
44541 PyThreadState* __tstate = wxPyBeginAllowThreads();
44542 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44543
44544 wxPyEndAllowThreads(__tstate);
44545 if (PyErr_Occurred()) SWIG_fail;
44546 }
44547 {
44548 resultobj = SWIG_From_int((int)(result));
44549 }
44550 return resultobj;
44551 fail:
44552 return NULL;
44553 }
44554
44555
44556 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44557 PyObject *resultobj;
44558 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44559 int result;
44560 PyObject * obj0 = 0 ;
44561 char *kwnames[] = {
44562 (char *) "self", NULL
44563 };
44564
44565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44567 if (SWIG_arg_fail(1)) SWIG_fail;
44568 {
44569 PyThreadState* __tstate = wxPyBeginAllowThreads();
44570 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44571
44572 wxPyEndAllowThreads(__tstate);
44573 if (PyErr_Occurred()) SWIG_fail;
44574 }
44575 {
44576 resultobj = SWIG_From_int((int)(result));
44577 }
44578 return resultobj;
44579 fail:
44580 return NULL;
44581 }
44582
44583
44584 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44585 PyObject *resultobj;
44586 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44587 int result;
44588 PyObject * obj0 = 0 ;
44589 char *kwnames[] = {
44590 (char *) "self", NULL
44591 };
44592
44593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44595 if (SWIG_arg_fail(1)) SWIG_fail;
44596 {
44597 PyThreadState* __tstate = wxPyBeginAllowThreads();
44598 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44599
44600 wxPyEndAllowThreads(__tstate);
44601 if (PyErr_Occurred()) SWIG_fail;
44602 }
44603 {
44604 resultobj = SWIG_From_int((int)(result));
44605 }
44606 return resultobj;
44607 fail:
44608 return NULL;
44609 }
44610
44611
44612 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44613 PyObject *resultobj;
44614 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44615 bool result;
44616 PyObject * obj0 = 0 ;
44617 char *kwnames[] = {
44618 (char *) "self", NULL
44619 };
44620
44621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44623 if (SWIG_arg_fail(1)) SWIG_fail;
44624 {
44625 PyThreadState* __tstate = wxPyBeginAllowThreads();
44626 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44627
44628 wxPyEndAllowThreads(__tstate);
44629 if (PyErr_Occurred()) SWIG_fail;
44630 }
44631 {
44632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44633 }
44634 return resultobj;
44635 fail:
44636 return NULL;
44637 }
44638
44639
44640 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44641 PyObject *resultobj;
44642 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44643 bool arg2 ;
44644 PyObject * obj0 = 0 ;
44645 PyObject * obj1 = 0 ;
44646 char *kwnames[] = {
44647 (char *) "self",(char *) "d", NULL
44648 };
44649
44650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44652 if (SWIG_arg_fail(1)) SWIG_fail;
44653 {
44654 arg2 = (bool)(SWIG_As_bool(obj1));
44655 if (SWIG_arg_fail(2)) SWIG_fail;
44656 }
44657 {
44658 PyThreadState* __tstate = wxPyBeginAllowThreads();
44659 (arg1)->SetDone(arg2);
44660
44661 wxPyEndAllowThreads(__tstate);
44662 if (PyErr_Occurred()) SWIG_fail;
44663 }
44664 Py_INCREF(Py_None); resultobj = Py_None;
44665 return resultobj;
44666 fail:
44667 return NULL;
44668 }
44669
44670
44671 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44672 PyObject *resultobj;
44673 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44674 wxRelationship result;
44675 PyObject * obj0 = 0 ;
44676 char *kwnames[] = {
44677 (char *) "self", NULL
44678 };
44679
44680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44682 if (SWIG_arg_fail(1)) SWIG_fail;
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 result = (wxRelationship)(arg1)->GetRelationship();
44686
44687 wxPyEndAllowThreads(__tstate);
44688 if (PyErr_Occurred()) SWIG_fail;
44689 }
44690 resultobj = SWIG_From_int((result));
44691 return resultobj;
44692 fail:
44693 return NULL;
44694 }
44695
44696
44697 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44698 PyObject *resultobj;
44699 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44700 wxRelationship arg2 ;
44701 PyObject * obj0 = 0 ;
44702 PyObject * obj1 = 0 ;
44703 char *kwnames[] = {
44704 (char *) "self",(char *) "r", NULL
44705 };
44706
44707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44709 if (SWIG_arg_fail(1)) SWIG_fail;
44710 {
44711 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44712 if (SWIG_arg_fail(2)) SWIG_fail;
44713 }
44714 {
44715 PyThreadState* __tstate = wxPyBeginAllowThreads();
44716 (arg1)->SetRelationship((wxRelationship )arg2);
44717
44718 wxPyEndAllowThreads(__tstate);
44719 if (PyErr_Occurred()) SWIG_fail;
44720 }
44721 Py_INCREF(Py_None); resultobj = Py_None;
44722 return resultobj;
44723 fail:
44724 return NULL;
44725 }
44726
44727
44728 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44729 PyObject *resultobj;
44730 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44731 wxWindow *arg2 = (wxWindow *) 0 ;
44732 bool result;
44733 PyObject * obj0 = 0 ;
44734 PyObject * obj1 = 0 ;
44735 char *kwnames[] = {
44736 (char *) "self",(char *) "otherW", NULL
44737 };
44738
44739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44741 if (SWIG_arg_fail(1)) SWIG_fail;
44742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44743 if (SWIG_arg_fail(2)) SWIG_fail;
44744 {
44745 PyThreadState* __tstate = wxPyBeginAllowThreads();
44746 result = (bool)(arg1)->ResetIfWin(arg2);
44747
44748 wxPyEndAllowThreads(__tstate);
44749 if (PyErr_Occurred()) SWIG_fail;
44750 }
44751 {
44752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44753 }
44754 return resultobj;
44755 fail:
44756 return NULL;
44757 }
44758
44759
44760 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44761 PyObject *resultobj;
44762 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44763 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44764 wxWindow *arg3 = (wxWindow *) 0 ;
44765 bool result;
44766 PyObject * obj0 = 0 ;
44767 PyObject * obj1 = 0 ;
44768 PyObject * obj2 = 0 ;
44769 char *kwnames[] = {
44770 (char *) "self",(char *) "constraints",(char *) "win", NULL
44771 };
44772
44773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44775 if (SWIG_arg_fail(1)) SWIG_fail;
44776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44777 if (SWIG_arg_fail(2)) SWIG_fail;
44778 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44779 if (SWIG_arg_fail(3)) SWIG_fail;
44780 {
44781 PyThreadState* __tstate = wxPyBeginAllowThreads();
44782 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44783
44784 wxPyEndAllowThreads(__tstate);
44785 if (PyErr_Occurred()) SWIG_fail;
44786 }
44787 {
44788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44789 }
44790 return resultobj;
44791 fail:
44792 return NULL;
44793 }
44794
44795
44796 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44797 PyObject *resultobj;
44798 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44799 wxEdge arg2 ;
44800 wxWindow *arg3 = (wxWindow *) 0 ;
44801 wxWindow *arg4 = (wxWindow *) 0 ;
44802 int result;
44803 PyObject * obj0 = 0 ;
44804 PyObject * obj1 = 0 ;
44805 PyObject * obj2 = 0 ;
44806 PyObject * obj3 = 0 ;
44807 char *kwnames[] = {
44808 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44809 };
44810
44811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44813 if (SWIG_arg_fail(1)) SWIG_fail;
44814 {
44815 arg2 = (wxEdge)(SWIG_As_int(obj1));
44816 if (SWIG_arg_fail(2)) SWIG_fail;
44817 }
44818 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44819 if (SWIG_arg_fail(3)) SWIG_fail;
44820 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44821 if (SWIG_arg_fail(4)) SWIG_fail;
44822 {
44823 PyThreadState* __tstate = wxPyBeginAllowThreads();
44824 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44825
44826 wxPyEndAllowThreads(__tstate);
44827 if (PyErr_Occurred()) SWIG_fail;
44828 }
44829 {
44830 resultobj = SWIG_From_int((int)(result));
44831 }
44832 return resultobj;
44833 fail:
44834 return NULL;
44835 }
44836
44837
44838 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44839 PyObject *obj;
44840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44841 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44842 Py_INCREF(obj);
44843 return Py_BuildValue((char *)"");
44844 }
44845 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44846 PyObject *resultobj;
44847 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44848 wxIndividualLayoutConstraint *result;
44849 PyObject * obj0 = 0 ;
44850 char *kwnames[] = {
44851 (char *) "self", NULL
44852 };
44853
44854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44856 if (SWIG_arg_fail(1)) SWIG_fail;
44857 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44858
44859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44860 return resultobj;
44861 fail:
44862 return NULL;
44863 }
44864
44865
44866 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44867 PyObject *resultobj;
44868 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44869 wxIndividualLayoutConstraint *result;
44870 PyObject * obj0 = 0 ;
44871 char *kwnames[] = {
44872 (char *) "self", NULL
44873 };
44874
44875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44877 if (SWIG_arg_fail(1)) SWIG_fail;
44878 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44879
44880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44881 return resultobj;
44882 fail:
44883 return NULL;
44884 }
44885
44886
44887 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44888 PyObject *resultobj;
44889 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44890 wxIndividualLayoutConstraint *result;
44891 PyObject * obj0 = 0 ;
44892 char *kwnames[] = {
44893 (char *) "self", NULL
44894 };
44895
44896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44898 if (SWIG_arg_fail(1)) SWIG_fail;
44899 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44900
44901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44902 return resultobj;
44903 fail:
44904 return NULL;
44905 }
44906
44907
44908 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44909 PyObject *resultobj;
44910 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44911 wxIndividualLayoutConstraint *result;
44912 PyObject * obj0 = 0 ;
44913 char *kwnames[] = {
44914 (char *) "self", NULL
44915 };
44916
44917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44919 if (SWIG_arg_fail(1)) SWIG_fail;
44920 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44921
44922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44923 return resultobj;
44924 fail:
44925 return NULL;
44926 }
44927
44928
44929 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44930 PyObject *resultobj;
44931 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44932 wxIndividualLayoutConstraint *result;
44933 PyObject * obj0 = 0 ;
44934 char *kwnames[] = {
44935 (char *) "self", NULL
44936 };
44937
44938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44940 if (SWIG_arg_fail(1)) SWIG_fail;
44941 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44942
44943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44944 return resultobj;
44945 fail:
44946 return NULL;
44947 }
44948
44949
44950 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44951 PyObject *resultobj;
44952 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44953 wxIndividualLayoutConstraint *result;
44954 PyObject * obj0 = 0 ;
44955 char *kwnames[] = {
44956 (char *) "self", NULL
44957 };
44958
44959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44961 if (SWIG_arg_fail(1)) SWIG_fail;
44962 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44963
44964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44965 return resultobj;
44966 fail:
44967 return NULL;
44968 }
44969
44970
44971 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44972 PyObject *resultobj;
44973 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44974 wxIndividualLayoutConstraint *result;
44975 PyObject * obj0 = 0 ;
44976 char *kwnames[] = {
44977 (char *) "self", NULL
44978 };
44979
44980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44982 if (SWIG_arg_fail(1)) SWIG_fail;
44983 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44984
44985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44986 return resultobj;
44987 fail:
44988 return NULL;
44989 }
44990
44991
44992 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44993 PyObject *resultobj;
44994 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44995 wxIndividualLayoutConstraint *result;
44996 PyObject * obj0 = 0 ;
44997 char *kwnames[] = {
44998 (char *) "self", NULL
44999 };
45000
45001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45003 if (SWIG_arg_fail(1)) SWIG_fail;
45004 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45005
45006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45007 return resultobj;
45008 fail:
45009 return NULL;
45010 }
45011
45012
45013 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45014 PyObject *resultobj;
45015 wxLayoutConstraints *result;
45016 char *kwnames[] = {
45017 NULL
45018 };
45019
45020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45021 {
45022 PyThreadState* __tstate = wxPyBeginAllowThreads();
45023 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45024
45025 wxPyEndAllowThreads(__tstate);
45026 if (PyErr_Occurred()) SWIG_fail;
45027 }
45028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45029 return resultobj;
45030 fail:
45031 return NULL;
45032 }
45033
45034
45035 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45036 PyObject *resultobj;
45037 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45038 wxWindow *arg2 = (wxWindow *) 0 ;
45039 int *arg3 = (int *) 0 ;
45040 bool result;
45041 int temp3 ;
45042 int res3 = 0 ;
45043 PyObject * obj0 = 0 ;
45044 PyObject * obj1 = 0 ;
45045 char *kwnames[] = {
45046 (char *) "self",(char *) "win", NULL
45047 };
45048
45049 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45052 if (SWIG_arg_fail(1)) SWIG_fail;
45053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45054 if (SWIG_arg_fail(2)) SWIG_fail;
45055 {
45056 PyThreadState* __tstate = wxPyBeginAllowThreads();
45057 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45058
45059 wxPyEndAllowThreads(__tstate);
45060 if (PyErr_Occurred()) SWIG_fail;
45061 }
45062 {
45063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45064 }
45065 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45066 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45067 return resultobj;
45068 fail:
45069 return NULL;
45070 }
45071
45072
45073 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45074 PyObject *resultobj;
45075 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45076 bool result;
45077 PyObject * obj0 = 0 ;
45078 char *kwnames[] = {
45079 (char *) "self", NULL
45080 };
45081
45082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45084 if (SWIG_arg_fail(1)) SWIG_fail;
45085 {
45086 PyThreadState* __tstate = wxPyBeginAllowThreads();
45087 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45088
45089 wxPyEndAllowThreads(__tstate);
45090 if (PyErr_Occurred()) SWIG_fail;
45091 }
45092 {
45093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45094 }
45095 return resultobj;
45096 fail:
45097 return NULL;
45098 }
45099
45100
45101 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45102 PyObject *obj;
45103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45104 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45105 Py_INCREF(obj);
45106 return Py_BuildValue((char *)"");
45107 }
45108 static PyMethodDef SwigMethods[] = {
45109 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45110 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45111 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45114 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45135 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45148 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45163 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45217 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45245 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45264 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45266 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45274 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45275 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45287 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45299 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45303 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45309 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45319 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45329 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45333 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45412 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45414 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45416 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45418 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45420 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45422 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45424 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45426 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45428 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45430 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45432 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45434 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45436 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45450 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45468 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45471 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45474 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45486 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45491 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45497 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45503 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45566 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45573 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45609 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45619 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45625 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45627 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45629 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45632 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45636 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45639 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45642 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45649 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45657 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45661 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45664 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45666 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45670 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45687 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45689 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45692 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45694 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45698 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45702 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45713 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45716 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45719 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45723 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45730 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45735 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45740 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45744 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45789 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45809 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45816 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45820 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45830 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46002 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46044 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46058 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46061 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46116 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46143 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46187 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46195 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46214 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46215 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46252 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46282 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46285 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46289 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46292 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46302 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46314 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46326 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46336 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46346 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46360 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46367 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46368 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46369 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46370 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46371 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46376 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46403 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46415 { NULL, NULL, 0, NULL }
46416 };
46417
46418
46419 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46420
46421 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46422 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46423 }
46424 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46425 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46426 }
46427 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46428 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46429 }
46430 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46431 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46432 }
46433 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46434 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46435 }
46436 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46437 return (void *)((wxSizer *) ((wxGridSizer *) x));
46438 }
46439 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46440 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46441 }
46442 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46443 return (void *)((wxSizer *) ((wxPySizer *) x));
46444 }
46445 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46446 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46447 }
46448 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46449 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46450 }
46451 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46452 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46453 }
46454 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46455 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46456 }
46457 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46458 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46459 }
46460 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46461 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46462 }
46463 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46464 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46465 }
46466 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46467 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46468 }
46469 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46470 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46471 }
46472 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46473 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46474 }
46475 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46476 return (void *)((wxEvent *) ((wxPyEvent *) x));
46477 }
46478 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46479 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46480 }
46481 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46482 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46483 }
46484 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46485 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46486 }
46487 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46488 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46489 }
46490 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46491 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46492 }
46493 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46494 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46495 }
46496 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46497 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46498 }
46499 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46500 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46501 }
46502 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46503 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46504 }
46505 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46506 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46507 }
46508 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46509 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46510 }
46511 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46512 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46513 }
46514 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46515 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46516 }
46517 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46518 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46519 }
46520 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46521 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46522 }
46523 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46524 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46525 }
46526 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46527 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46528 }
46529 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46530 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46531 }
46532 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46533 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46534 }
46535 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46536 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46537 }
46538 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46539 return (void *)((wxEvent *) ((wxShowEvent *) x));
46540 }
46541 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46542 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46543 }
46544 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46545 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46546 }
46547 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46548 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46549 }
46550 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46551 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46552 }
46553 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46554 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46555 }
46556 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46557 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46558 }
46559 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46560 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46561 }
46562 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46563 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46564 }
46565 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46566 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46567 }
46568 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46569 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46570 }
46571 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46572 return (void *)((wxControl *) ((wxControlWithItems *) x));
46573 }
46574 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46575 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46576 }
46577 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46578 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46579 }
46580 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46581 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46582 }
46583 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46584 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46585 }
46586 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46587 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46588 }
46589 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46590 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46591 }
46592 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46593 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46594 }
46595 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46596 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46597 }
46598 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46599 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46600 }
46601 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46602 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46603 }
46604 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46605 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46606 }
46607 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46608 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46609 }
46610 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46611 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46612 }
46613 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46614 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46615 }
46616 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46617 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46618 }
46619 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46620 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46621 }
46622 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46623 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46624 }
46625 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46626 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46627 }
46628 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46629 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46630 }
46631 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46632 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46633 }
46634 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46635 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46636 }
46637 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46638 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46639 }
46640 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46641 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46642 }
46643 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46644 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46645 }
46646 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46647 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46648 }
46649 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46650 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46651 }
46652 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46653 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46654 }
46655 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46656 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46657 }
46658 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46659 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46660 }
46661 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46662 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46663 }
46664 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46665 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46666 }
46667 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46668 return (void *)((wxObject *) ((wxSizerItem *) x));
46669 }
46670 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46671 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46672 }
46673 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46674 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46675 }
46676 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46677 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46678 }
46679 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46680 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46681 }
46682 static void *_p_wxSizerTo_p_wxObject(void *x) {
46683 return (void *)((wxObject *) ((wxSizer *) x));
46684 }
46685 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46686 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46687 }
46688 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46689 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46690 }
46691 static void *_p_wxEventTo_p_wxObject(void *x) {
46692 return (void *)((wxObject *) ((wxEvent *) x));
46693 }
46694 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46695 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46696 }
46697 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46698 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46699 }
46700 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46701 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46702 }
46703 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46704 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46705 }
46706 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46707 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46708 }
46709 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46710 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46711 }
46712 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46713 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46714 }
46715 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46716 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46717 }
46718 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46719 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46720 }
46721 static void *_p_wxControlTo_p_wxObject(void *x) {
46722 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46723 }
46724 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46725 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46726 }
46727 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46728 return (void *)((wxObject *) ((wxFSFile *) x));
46729 }
46730 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46731 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46732 }
46733 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46734 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46735 }
46736 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46737 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46738 }
46739 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46740 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46741 }
46742 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46743 return (void *)((wxObject *) ((wxMenuItem *) x));
46744 }
46745 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46746 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46747 }
46748 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46749 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46750 }
46751 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46752 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46753 }
46754 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46755 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46756 }
46757 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46758 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46759 }
46760 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46761 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46762 }
46763 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46764 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46765 }
46766 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46767 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46768 }
46769 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46770 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46771 }
46772 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46773 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46774 }
46775 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46776 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46777 }
46778 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46779 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46780 }
46781 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46782 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46783 }
46784 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46785 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46786 }
46787 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46788 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46789 }
46790 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46791 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46792 }
46793 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46794 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46795 }
46796 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46797 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46798 }
46799 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46800 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46801 }
46802 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46803 return (void *)((wxObject *) ((wxImageHandler *) x));
46804 }
46805 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46806 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46807 }
46808 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46809 return (void *)((wxObject *) ((wxEvtHandler *) x));
46810 }
46811 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46812 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46813 }
46814 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46815 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46816 }
46817 static void *_p_wxImageTo_p_wxObject(void *x) {
46818 return (void *)((wxObject *) ((wxImage *) x));
46819 }
46820 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46821 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46822 }
46823 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46824 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46825 }
46826 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46827 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46828 }
46829 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46830 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46831 }
46832 static void *_p_wxWindowTo_p_wxObject(void *x) {
46833 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46834 }
46835 static void *_p_wxMenuTo_p_wxObject(void *x) {
46836 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46837 }
46838 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46839 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46840 }
46841 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46842 return (void *)((wxObject *) ((wxFileSystem *) x));
46843 }
46844 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46845 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46846 }
46847 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46848 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46849 }
46850 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46851 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46852 }
46853 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46854 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46855 }
46856 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46857 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46858 }
46859 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46860 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46861 }
46862 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46863 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46864 }
46865 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46866 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46867 }
46868 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46869 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46870 }
46871 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46872 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46873 }
46874 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46875 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46876 }
46877 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46878 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46879 }
46880 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46881 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46882 }
46883 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46884 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46885 }
46886 static void *_p_wxControlTo_p_wxWindow(void *x) {
46887 return (void *)((wxWindow *) ((wxControl *) x));
46888 }
46889 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46890 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46891 }
46892 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46893 return (void *)((wxWindow *) ((wxMenuBar *) x));
46894 }
46895 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46896 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46897 }
46898 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46899 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46900 }
46901 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46902 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46903 }
46904 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46905 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46906 }
46907 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46908 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46909 }
46910 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46911 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46912 }
46913 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46914 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46915 }
46916 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46917 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46918 }
46919 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46920 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46921 }
46922 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46923 return (void *)((wxValidator *) ((wxPyValidator *) x));
46924 }
46925 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}};
46926 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}};
46927 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}};
46928 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}};
46929 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}};
46930 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}};
46931 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}};
46932 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}};
46933 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}};
46934 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}};
46935 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}};
46936 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}};
46937 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}};
46938 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46939 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}};
46940 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}};
46941 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}};
46942 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}};
46943 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}};
46944 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}};
46945 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}};
46946 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}};
46947 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}};
46948 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}};
46949 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}};
46950 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}};
46951 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}};
46952 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}};
46953 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}};
46954 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}};
46955 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}};
46956 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}};
46957 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}};
46958 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}};
46959 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}};
46960 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}};
46961 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}};
46962 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}};
46963 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}};
46964 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}};
46965 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}};
46966 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}};
46967 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}};
46968 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}};
46969 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}};
46970 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}};
46971 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}};
46972 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}};
46973 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}};
46974 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}};
46975 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}};
46976 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}};
46977 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}};
46978 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}};
46979 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}};
46980 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}};
46981 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46982 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}};
46983 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}};
46984 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}};
46985 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}};
46986 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}};
46987 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}};
46988 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}};
46989 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}};
46990 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}};
46991 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}};
46992 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}};
46993 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}};
46994 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}};
46995 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}};
46996 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}};
46997 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}};
46998 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}};
46999 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}};
47000 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}};
47001 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}};
47002 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}};
47003 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}};
47004 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}};
47005 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}};
47006 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}};
47007 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}};
47008 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}};
47009 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}};
47010 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}};
47011 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}};
47012 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}};
47013 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}};
47014 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}};
47015 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}};
47016 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}};
47017 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}};
47018 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}};
47019 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47020 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}};
47021 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}};
47022 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}};
47023 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}};
47024 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}};
47025 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}};
47026 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}};
47027 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}};
47028 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}};
47029 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}};
47030 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}};
47031 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}};
47032 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}};
47033 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}};
47034 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}};
47035 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}};
47036 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47037 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}};
47038 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}};
47039 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}};
47040 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}};
47041 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47042 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}};
47043 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}};
47044 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}};
47045 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}};
47046 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}};
47047 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}};
47048 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}};
47049 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}};
47050 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}};
47051 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}};
47052
47053 static swig_type_info *swig_types_initial[] = {
47054 _swigt__p_wxLayoutConstraints,
47055 _swigt__p_wxRealPoint,
47056 _swigt__p_wxSizerItem,
47057 _swigt__p_wxGBSizerItem,
47058 _swigt__p_wxScrollEvent,
47059 _swigt__p_wxEventLoop,
47060 _swigt__p_wxIndividualLayoutConstraint,
47061 _swigt__p_wxSizer,
47062 _swigt__p_wxBoxSizer,
47063 _swigt__p_wxStaticBoxSizer,
47064 _swigt__p_wxGridBagSizer,
47065 _swigt__p_wxAcceleratorEntry,
47066 _swigt__p_wxUpdateUIEvent,
47067 _swigt__p_wxEvent,
47068 _swigt__p_wxMenu,
47069 _swigt__p_wxGridSizer,
47070 _swigt__p_wxFlexGridSizer,
47071 _swigt__p_wxInitDialogEvent,
47072 _swigt__p_wxItemContainer,
47073 _swigt__p_wxNcPaintEvent,
47074 _swigt__p_wxPaintEvent,
47075 _swigt__p_wxSysColourChangedEvent,
47076 _swigt__p_wxMouseCaptureChangedEvent,
47077 _swigt__p_wxDisplayChangedEvent,
47078 _swigt__p_wxPaletteChangedEvent,
47079 _swigt__p_wxControl,
47080 _swigt__p_wxFont,
47081 _swigt__p_wxMenuBarBase,
47082 _swigt__p_wxSetCursorEvent,
47083 _swigt__p_wxFSFile,
47084 _swigt__p_wxCaret,
47085 _swigt__ptrdiff_t,
47086 _swigt__std__ptrdiff_t,
47087 _swigt__p_wxRegion,
47088 _swigt__p_wxPoint2D,
47089 _swigt__p_int,
47090 _swigt__p_wxSize,
47091 _swigt__p_wxDC,
47092 _swigt__p_wxPySizer,
47093 _swigt__p_wxVisualAttributes,
47094 _swigt__p_wxNotifyEvent,
47095 _swigt__p_wxPyEvent,
47096 _swigt__p_wxPropagationDisabler,
47097 _swigt__p_form_ops_t,
47098 _swigt__p_wxAppTraits,
47099 _swigt__p_wxArrayString,
47100 _swigt__p_wxShowEvent,
47101 _swigt__p_wxToolTip,
47102 _swigt__p_wxMoveEvent,
47103 _swigt__p_wxSizeEvent,
47104 _swigt__p_wxActivateEvent,
47105 _swigt__p_wxIconizeEvent,
47106 _swigt__p_wxMaximizeEvent,
47107 _swigt__p_wxQueryNewPaletteEvent,
47108 _swigt__p_wxWindowCreateEvent,
47109 _swigt__p_wxIdleEvent,
47110 _swigt__p_wxDateEvent,
47111 _swigt__p_wxMenuItem,
47112 _swigt__p_wxStaticBox,
47113 _swigt__p_long,
47114 _swigt__p_wxDuplexMode,
47115 _swigt__p_wxTIFFHandler,
47116 _swigt__p_wxXPMHandler,
47117 _swigt__p_wxPNMHandler,
47118 _swigt__p_wxJPEGHandler,
47119 _swigt__p_wxPCXHandler,
47120 _swigt__p_wxGIFHandler,
47121 _swigt__p_wxPNGHandler,
47122 _swigt__p_wxANIHandler,
47123 _swigt__p_wxMemoryFSHandler,
47124 _swigt__p_wxZipFSHandler,
47125 _swigt__p_wxInternetFSHandler,
47126 _swigt__p_wxPyFileSystemHandler,
47127 _swigt__p_wxEvtHandler,
47128 _swigt__p_wxCURHandler,
47129 _swigt__p_wxICOHandler,
47130 _swigt__p_wxBMPHandler,
47131 _swigt__p_wxImageHandler,
47132 _swigt__p_wxFileSystemHandler,
47133 _swigt__p_wxRect,
47134 _swigt__p_wxButton,
47135 _swigt__p_wxGBSpan,
47136 _swigt__p_wxPropagateOnce,
47137 _swigt__p_wxAcceleratorTable,
47138 _swigt__p_wxStdDialogButtonSizer,
47139 _swigt__p_char,
47140 _swigt__p_wxGBPosition,
47141 _swigt__p_wxImage,
47142 _swigt__p_wxFrame,
47143 _swigt__p_wxScrollWinEvent,
47144 _swigt__p_wxPaperSize,
47145 _swigt__p_wxImageHistogram,
47146 _swigt__p_wxPoint,
47147 _swigt__p_wxCursor,
47148 _swigt__p_wxObject,
47149 _swigt__p_wxInputStream,
47150 _swigt__p_wxOutputStream,
47151 _swigt__p_wxPyInputStream,
47152 _swigt__p_wxDateTime,
47153 _swigt__p_wxKeyEvent,
47154 _swigt__p_wxNavigationKeyEvent,
47155 _swigt__p_wxWindowDestroyEvent,
47156 _swigt__p_unsigned_long,
47157 _swigt__p_wxWindow,
47158 _swigt__p_wxMenuBar,
47159 _swigt__p_wxFileSystem,
47160 _swigt__p_wxBitmap,
47161 _swigt__unsigned_int,
47162 _swigt__p_unsigned_int,
47163 _swigt__p_wxMenuEvent,
47164 _swigt__p_wxContextMenuEvent,
47165 _swigt__p_unsigned_char,
47166 _swigt__p_wxEraseEvent,
47167 _swigt__p_wxMouseEvent,
47168 _swigt__p_wxCloseEvent,
47169 _swigt__p_wxPyApp,
47170 _swigt__p_wxCommandEvent,
47171 _swigt__p_wxPyCommandEvent,
47172 _swigt__p_wxPyDropTarget,
47173 _swigt__p_wxQuantize,
47174 _swigt__p_wxChildFocusEvent,
47175 _swigt__p_wxFocusEvent,
47176 _swigt__p_wxDropFilesEvent,
47177 _swigt__p_wxControlWithItems,
47178 _swigt__p_wxColour,
47179 _swigt__p_wxValidator,
47180 _swigt__p_wxPyValidator,
47181 0
47182 };
47183
47184
47185 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47186
47187 static swig_const_info swig_const_table[] = {
47188 {0, 0, 0, 0.0, 0, 0}};
47189
47190 #ifdef __cplusplus
47191 }
47192 #endif
47193
47194
47195 #ifdef __cplusplus
47196 extern "C" {
47197 #endif
47198
47199 /* Python-specific SWIG API */
47200 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47201 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47202 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47203
47204 /* -----------------------------------------------------------------------------
47205 * global variable support code.
47206 * ----------------------------------------------------------------------------- */
47207
47208 typedef struct swig_globalvar {
47209 char *name; /* Name of global variable */
47210 PyObject *(*get_attr)(); /* Return the current value */
47211 int (*set_attr)(PyObject *); /* Set the value */
47212 struct swig_globalvar *next;
47213 } swig_globalvar;
47214
47215 typedef struct swig_varlinkobject {
47216 PyObject_HEAD
47217 swig_globalvar *vars;
47218 } swig_varlinkobject;
47219
47220 static PyObject *
47221 swig_varlink_repr(swig_varlinkobject *v) {
47222 v = v;
47223 return PyString_FromString("<Swig global variables>");
47224 }
47225
47226 static int
47227 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47228 swig_globalvar *var;
47229 flags = flags;
47230 fprintf(fp,"Swig global variables { ");
47231 for (var = v->vars; var; var=var->next) {
47232 fprintf(fp,"%s", var->name);
47233 if (var->next) fprintf(fp,", ");
47234 }
47235 fprintf(fp," }\n");
47236 return 0;
47237 }
47238
47239 static PyObject *
47240 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47241 swig_globalvar *var = v->vars;
47242 while (var) {
47243 if (strcmp(var->name,n) == 0) {
47244 return (*var->get_attr)();
47245 }
47246 var = var->next;
47247 }
47248 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47249 return NULL;
47250 }
47251
47252 static int
47253 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47254 swig_globalvar *var = v->vars;
47255 while (var) {
47256 if (strcmp(var->name,n) == 0) {
47257 return (*var->set_attr)(p);
47258 }
47259 var = var->next;
47260 }
47261 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47262 return 1;
47263 }
47264
47265 static PyTypeObject varlinktype = {
47266 PyObject_HEAD_INIT(0)
47267 0, /* Number of items in variable part (ob_size) */
47268 (char *)"swigvarlink", /* Type name (tp_name) */
47269 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47270 0, /* Itemsize (tp_itemsize) */
47271 0, /* Deallocator (tp_dealloc) */
47272 (printfunc) swig_varlink_print, /* Print (tp_print) */
47273 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47274 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47275 0, /* tp_compare */
47276 (reprfunc) swig_varlink_repr, /* tp_repr */
47277 0, /* tp_as_number */
47278 0, /* tp_as_sequence */
47279 0, /* tp_as_mapping */
47280 0, /* tp_hash */
47281 0, /* tp_call */
47282 0, /* tp_str */
47283 0, /* tp_getattro */
47284 0, /* tp_setattro */
47285 0, /* tp_as_buffer */
47286 0, /* tp_flags */
47287 0, /* tp_doc */
47288 #if PY_VERSION_HEX >= 0x02000000
47289 0, /* tp_traverse */
47290 0, /* tp_clear */
47291 #endif
47292 #if PY_VERSION_HEX >= 0x02010000
47293 0, /* tp_richcompare */
47294 0, /* tp_weaklistoffset */
47295 #endif
47296 #if PY_VERSION_HEX >= 0x02020000
47297 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47298 #endif
47299 #if PY_VERSION_HEX >= 0x02030000
47300 0, /* tp_del */
47301 #endif
47302 #ifdef COUNT_ALLOCS
47303 0,0,0,0 /* tp_alloc -> tp_next */
47304 #endif
47305 };
47306
47307 /* Create a variable linking object for use later */
47308 static PyObject *
47309 SWIG_Python_newvarlink(void) {
47310 swig_varlinkobject *result = 0;
47311 result = PyMem_NEW(swig_varlinkobject,1);
47312 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47313 result->ob_type = &varlinktype;
47314 result->vars = 0;
47315 result->ob_refcnt = 0;
47316 Py_XINCREF((PyObject *) result);
47317 return ((PyObject*) result);
47318 }
47319
47320 static void
47321 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47322 swig_varlinkobject *v;
47323 swig_globalvar *gv;
47324 v= (swig_varlinkobject *) p;
47325 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47326 gv->name = (char *) malloc(strlen(name)+1);
47327 strcpy(gv->name,name);
47328 gv->get_attr = get_attr;
47329 gv->set_attr = set_attr;
47330 gv->next = v->vars;
47331 v->vars = gv;
47332 }
47333
47334 /* -----------------------------------------------------------------------------
47335 * constants/methods manipulation
47336 * ----------------------------------------------------------------------------- */
47337
47338 /* Install Constants */
47339 static void
47340 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47341 PyObject *obj = 0;
47342 size_t i;
47343 for (i = 0; constants[i].type; i++) {
47344 switch(constants[i].type) {
47345 case SWIG_PY_INT:
47346 obj = PyInt_FromLong(constants[i].lvalue);
47347 break;
47348 case SWIG_PY_FLOAT:
47349 obj = PyFloat_FromDouble(constants[i].dvalue);
47350 break;
47351 case SWIG_PY_STRING:
47352 if (constants[i].pvalue) {
47353 obj = PyString_FromString((char *) constants[i].pvalue);
47354 } else {
47355 Py_INCREF(Py_None);
47356 obj = Py_None;
47357 }
47358 break;
47359 case SWIG_PY_POINTER:
47360 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47361 break;
47362 case SWIG_PY_BINARY:
47363 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47364 break;
47365 default:
47366 obj = 0;
47367 break;
47368 }
47369 if (obj) {
47370 PyDict_SetItemString(d,constants[i].name,obj);
47371 Py_DECREF(obj);
47372 }
47373 }
47374 }
47375
47376 /* -----------------------------------------------------------------------------*/
47377 /* Fix SwigMethods to carry the callback ptrs when needed */
47378 /* -----------------------------------------------------------------------------*/
47379
47380 static void
47381 SWIG_Python_FixMethods(PyMethodDef *methods,
47382 swig_const_info *const_table,
47383 swig_type_info **types,
47384 swig_type_info **types_initial) {
47385 size_t i;
47386 for (i = 0; methods[i].ml_name; ++i) {
47387 char *c = methods[i].ml_doc;
47388 if (c && (c = strstr(c, "swig_ptr: "))) {
47389 int j;
47390 swig_const_info *ci = 0;
47391 char *name = c + 10;
47392 for (j = 0; const_table[j].type; j++) {
47393 if (strncmp(const_table[j].name, name,
47394 strlen(const_table[j].name)) == 0) {
47395 ci = &(const_table[j]);
47396 break;
47397 }
47398 }
47399 if (ci) {
47400 size_t shift = (ci->ptype) - types;
47401 swig_type_info *ty = types_initial[shift];
47402 size_t ldoc = (c - methods[i].ml_doc);
47403 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47404 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47405 char *buff = ndoc;
47406 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47407 strncpy(buff, methods[i].ml_doc, ldoc);
47408 buff += ldoc;
47409 strncpy(buff, "swig_ptr: ", 10);
47410 buff += 10;
47411 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47412 methods[i].ml_doc = ndoc;
47413 }
47414 }
47415 }
47416 }
47417
47418 /* -----------------------------------------------------------------------------*
47419 * Initialize type list
47420 * -----------------------------------------------------------------------------*/
47421
47422 #if PY_MAJOR_VERSION < 2
47423 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47424 is copied out of Python/modsupport.c in python version 2.3.4 */
47425 static int
47426 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47427 {
47428 PyObject *dict;
47429 if (!PyModule_Check(m)) {
47430 PyErr_SetString(PyExc_TypeError,
47431 "PyModule_AddObject() needs module as first arg");
47432 return -1;
47433 }
47434 if (!o) {
47435 PyErr_SetString(PyExc_TypeError,
47436 "PyModule_AddObject() needs non-NULL value");
47437 return -1;
47438 }
47439
47440 dict = PyModule_GetDict(m);
47441 if (dict == NULL) {
47442 /* Internal error -- modules must have a dict! */
47443 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47444 PyModule_GetName(m));
47445 return -1;
47446 }
47447 if (PyDict_SetItemString(dict, name, o))
47448 return -1;
47449 Py_DECREF(o);
47450 return 0;
47451 }
47452 #endif
47453
47454 static swig_type_info **
47455 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47456 static PyMethodDef swig_empty_runtime_method_table[] = {
47457 {
47458 NULL, NULL, 0, NULL
47459 }
47460 };/* Sentinel */
47461
47462 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47463 swig_empty_runtime_method_table);
47464 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47465 if (pointer && module) {
47466 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47467 }
47468 return type_list_handle;
47469 }
47470
47471 static swig_type_info **
47472 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47473 swig_type_info **type_pointer;
47474
47475 /* first check if module already created */
47476 type_pointer = SWIG_Python_GetTypeListHandle();
47477 if (type_pointer) {
47478 return type_pointer;
47479 } else {
47480 /* create a new module and variable */
47481 return SWIG_Python_SetTypeListHandle(type_list_handle);
47482 }
47483 }
47484
47485 #ifdef __cplusplus
47486 }
47487 #endif
47488
47489 /* -----------------------------------------------------------------------------*
47490 * Partial Init method
47491 * -----------------------------------------------------------------------------*/
47492
47493 #ifdef SWIG_LINK_RUNTIME
47494 #ifdef __cplusplus
47495 extern "C"
47496 #endif
47497 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47498 #endif
47499
47500 #ifdef __cplusplus
47501 extern "C"
47502 #endif
47503 SWIGEXPORT(void) SWIG_init(void) {
47504 static PyObject *SWIG_globals = 0;
47505 static int typeinit = 0;
47506 PyObject *m, *d;
47507 int i;
47508 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47509
47510 /* Fix SwigMethods to carry the callback ptrs when needed */
47511 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47512
47513 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47514 d = PyModule_GetDict(m);
47515
47516 if (!typeinit) {
47517 #ifdef SWIG_LINK_RUNTIME
47518 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47519 #else
47520 # ifndef SWIG_STATIC_RUNTIME
47521 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47522 # endif
47523 #endif
47524 for (i = 0; swig_types_initial[i]; i++) {
47525 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47526 }
47527 typeinit = 1;
47528 }
47529 SWIG_InstallConstants(d,swig_const_table);
47530
47531
47532 #ifndef wxPyUSE_EXPORT
47533 // Make our API structure a CObject so other modules can import it
47534 // from this module.
47535 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47536 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47537 Py_XDECREF(cobj);
47538 #endif
47539
47540 {
47541 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47542 }
47543 {
47544 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47545 }
47546 {
47547 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47548 }
47549 {
47550 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47551 }
47552 {
47553 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47554 }
47555 {
47556 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47557 }
47558 {
47559 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47560 }
47561 {
47562 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47563 }
47564 {
47565 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47566 }
47567 {
47568 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49192 }
49193 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49194 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49195 {
49196 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49347 }
49348 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49349 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49350 {
49351 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49358 }
49359
49360 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49361
49362
49363 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49364
49365 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49366 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49367 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49368 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49369 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49370 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49371 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49372 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49373 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49374 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49375 {
49376 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49380 }
49381 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49382 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49383 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49384 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49385 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49386 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49387 {
49388 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49434 }
49435 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49436 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49437 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49438 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49439 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49440 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49441 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49442 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49443 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49444 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49445 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49446 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49447 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49448 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49449 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49450 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49451 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49452 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49453 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49454 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49455 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49456 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49457 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49458 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49459 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49460 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49461 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49462 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49463 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49464 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49465 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49466 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49467 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49468 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49469 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49470 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49471 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49472 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49473 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49474 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49475 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49476 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49477 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49478 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49479 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49480 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49481 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49482 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49483 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49484 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49485 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49486 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49487 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49488 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49489 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49490 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49491 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49492 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49493 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49494 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49495 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49496 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49497 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49498 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49499 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49500 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49501 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49502 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49503 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49504 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49505 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49506 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49507 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49508 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49509 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49510 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49511 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49512 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49513 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49514 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49515 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49516 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49517 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49518 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49519 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49520 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49521 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49522 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49523 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49524 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49525 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49526 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49527 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49528 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49529 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49530 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49531 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49532 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49533 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49534 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49535 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49536 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49537 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49538 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49539 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49540 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49541 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49542 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49543 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49544 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49545 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49546 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49547 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49548 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49549 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49550 {
49551 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49588 }
49589 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49590 {
49591 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49607 }
49608 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49609 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49610 {
49611 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49618 }
49619 {
49620 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49621 }
49622 {
49623 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49624 }
49625 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49626 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49627 {
49628 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49635 }
49636 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49637 {
49638 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49693 }
49694
49695 // Initialize threading, some globals and such
49696 __wxPyPreStart(d);
49697
49698
49699 // Although these are defined in __version__ they need to be here too so
49700 // that an assert can be done to ensure that the wxPython and the wxWindows
49701 // versions match.
49702 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49703 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49704 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49705
49706 }
49707
wxWidgets (Impactor)