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


4b3a7769b259a076d5a7036fb1d7de5b26ba8e85
[wxWidgets.git] / wxPython / src / gtk / _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
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2475 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2476 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2477 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2478
2479 #include <wx/quantize.h>
2480
2481 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2482 return wxQuantize::Quantize(src, dest,
2483 //NULL, // palette
2484 desiredNoColours,
2485 NULL, // eightBitData
2486 flags);
2487 }
2488 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2489 if (PyCallable_Check(func)) {
2490 self->Connect(id, lastId, eventType,
2491 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2492 new wxPyCallback(func));
2493 }
2494 else if (func == Py_None) {
2495 self->Disconnect(id, lastId, eventType,
2496 (wxObjectEventFunction)
2497 &wxPyCallback::EventThunker);
2498 }
2499 else {
2500 wxPyBLOCK_THREADS(
2501 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2502 }
2503 }
2504 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2505 return self->Disconnect(id, lastId, eventType,
2506 (wxObjectEventFunction)
2507 &wxPyCallback::EventThunker);
2508 }
2509 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2510 if (_self && _self != Py_None) {
2511 self->SetClientObject(new wxPyOORClientData(_self, incref));
2512 }
2513 else {
2514 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2515 if (data) {
2516 self->SetClientObject(NULL); // This will delete it too
2517 }
2518 }
2519 }
2520
2521 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2522 #if wxUSE_UNICODE
2523 return self->GetUnicodeKey();
2524 #else
2525 return 0;
2526 #endif
2527 }
2528
2529 #if UINT_MAX < LONG_MAX
2530 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2531 #define SWIG_From_unsigned_SS_int SWIG_From_long
2532 /*@@*/
2533 #else
2534 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2536 /*@@*/
2537 #endif
2538
2539
2540 #if UINT_MAX != ULONG_MAX
2541 SWIGINTERN int
2542 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2543 {
2544 const char* errmsg = val ? "unsigned int" : (char*)0;
2545 unsigned long v;
2546 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2547 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2548 if (val) *val = (unsigned int)(v);
2549 return 1;
2550 }
2551 } else {
2552 PyErr_Clear();
2553 }
2554 if (val) {
2555 SWIG_type_error(errmsg, obj);
2556 }
2557 return 0;
2558 }
2559 #else
2560 SWIGINTERNSHORT unsigned int
2561 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2562 {
2563 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2564 }
2565 #endif
2566
2567
2568 SWIGINTERNSHORT unsigned int
2569 SWIG_As_unsigned_SS_int(PyObject* obj)
2570 {
2571 unsigned int v;
2572 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2573 /*
2574 this is needed to make valgrind/purify happier.
2575 */
2576 memset((void*)&v, 0, sizeof(unsigned int));
2577 }
2578 return v;
2579 }
2580
2581
2582 SWIGINTERNSHORT int
2583 SWIG_Check_unsigned_SS_int(PyObject* obj)
2584 {
2585 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2586 }
2587
2588 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2589 self->m_size = size;
2590 }
2591 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2592 int count = self->GetNumberOfFiles();
2593 wxString* files = self->GetFiles();
2594 PyObject* list = PyList_New(count);
2595
2596 if (!list) {
2597 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2598 return NULL;
2599 }
2600
2601 for (int i=0; i<count; i++) {
2602 PyList_SetItem(list, i, wx2PyString(files[i]));
2603 }
2604 return list;
2605 }
2606
2607
2608 static wxPyApp *new_wxPyApp(){
2609 wxPythonApp = new wxPyApp();
2610 return wxPythonApp;
2611 }
2612 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2613
2614 void wxApp_CleanUp() {
2615 __wxPyCleanup();
2616 }
2617
2618
2619 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2620
2621
2622 SWIGINTERNSHORT int
2623 SWIG_AsCharPtr(PyObject *obj, char **val)
2624 {
2625 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2626 return 1;
2627 }
2628 if (val) {
2629 PyErr_Clear();
2630 SWIG_type_error("char *", obj);
2631 }
2632 return 0;
2633 }
2634
2635
2636 SWIGINTERN PyObject *
2637 SWIG_FromCharPtr(const char* cptr)
2638 {
2639 if (cptr) {
2640 size_t size = strlen(cptr);
2641 if (size > INT_MAX) {
2642 return SWIG_NewPointerObj((char*)(cptr),
2643 SWIG_TypeQuery("char *"), 0);
2644 } else {
2645 if (size != 0) {
2646 return PyString_FromStringAndSize(cptr, size);
2647 } else {
2648 return PyString_FromString(cptr);
2649 }
2650 }
2651 }
2652 Py_INCREF(Py_None);
2653 return Py_None;
2654 }
2655
2656
2657 #ifdef __WXMAC__
2658
2659 // A dummy class that raises an exception if used...
2660 class wxEventLoop
2661 {
2662 public:
2663 wxEventLoop() { wxPyRaiseNotImplemented(); }
2664 int Run() { return 0; }
2665 void Exit(int rc = 0) {}
2666 bool Pending() const { return false; }
2667 bool Dispatch() { return false; }
2668 bool IsRunning() const { return false; }
2669 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2670 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2671 };
2672
2673 #else
2674
2675 #include <wx/evtloop.h>
2676
2677 #endif
2678
2679
2680
2681 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2682 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2683 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2684 static PyObject *wxWindow_GetChildren(wxWindow *self){
2685 wxWindowList& list = self->GetChildren();
2686 return wxPy_ConvertList(&list);
2687 }
2688 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2689 #if wxUSE_HOTKEY
2690 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2691 #else
2692 return false;
2693 #endif
2694 }
2695 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2696
2697
2698
2699 return false;
2700
2701 }
2702 static long wxWindow_GetHandle(wxWindow *self){
2703 return wxPyGetWinHandle(self);
2704 }
2705 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2706 self->AssociateHandle((WXWidget)handle);
2707 }
2708
2709 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2710 return wxWindow::FindWindowById(id, parent);
2711 }
2712
2713 wxWindow* wxFindWindowByName( const wxString& name,
2714 const wxWindow *parent = NULL ) {
2715 return wxWindow::FindWindowByName(name, parent);
2716 }
2717
2718 wxWindow* wxFindWindowByLabel( const wxString& label,
2719 const wxWindow *parent = NULL ) {
2720 return wxWindow::FindWindowByLabel(label, parent);
2721 }
2722
2723
2724 #ifdef __WXMSW__
2725 #include <wx/msw/private.h> // to get wxGetWindowId
2726 #endif
2727
2728
2729 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2730 #ifdef __WXMSW__
2731 WXHWND hWnd = (WXHWND)_hWnd;
2732 long id = wxGetWindowId(hWnd);
2733 wxWindow* win = new wxWindow;
2734 parent->AddChild(win);
2735 win->SetEventHandler(win);
2736 win->SetHWND(hWnd);
2737 win->SetId(id);
2738 win->SubclassWin(hWnd);
2739 win->AdoptAttributesFromHWND();
2740 win->SetupColours();
2741 return win;
2742 #else
2743 wxPyRaiseNotImplemented();
2744 return NULL;
2745 #endif
2746 }
2747
2748
2749 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2750 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2751 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2752
2753 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2754
2755 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2756 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2757 wxMenuItemList& list = self->GetMenuItems();
2758 return wxPy_ConvertList(&list);
2759 }
2760 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2761 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2762 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2763 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2764 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2765 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2766 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2767 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2768 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2769 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2770 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2771 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2772 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2773 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2774 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2775 static const wxString wxPyControlNameStr(wxControlNameStr);
2776 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2777 if (clientData) {
2778 wxPyClientData* data = new wxPyClientData(clientData);
2779 return self->Append(item, data);
2780 } else
2781 return self->Append(item);
2782 }
2783 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2784 if (clientData) {
2785 wxPyClientData* data = new wxPyClientData(clientData);
2786 return self->Insert(item, pos, data);
2787 } else
2788 return self->Insert(item, pos);
2789 }
2790 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2791 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2792 if (data) {
2793 Py_INCREF(data->m_obj);
2794 return data->m_obj;
2795 } else {
2796 Py_INCREF(Py_None);
2797 return Py_None;
2798 }
2799 }
2800 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2801 wxPyClientData* data = new wxPyClientData(clientData);
2802 self->SetClientObject(n, data);
2803 }
2804
2805
2806 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2807 wxPyUserData* data = NULL;
2808 if ( userData ) {
2809 bool blocked = wxPyBeginBlockThreads();
2810 data = new wxPyUserData(userData);
2811 wxPyEndBlockThreads(blocked);
2812 }
2813 return new wxSizerItem(window, proportion, flag, border, data);
2814 }
2815 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2816 wxPyUserData* data = NULL;
2817 if ( userData ) {
2818 bool blocked = wxPyBeginBlockThreads();
2819 data = new wxPyUserData(userData);
2820 wxPyEndBlockThreads(blocked);
2821 }
2822 return new wxSizerItem(width, height, proportion, flag, border, data);
2823 }
2824 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2825 wxPyUserData* data = NULL;
2826 if ( userData ) {
2827 bool blocked = wxPyBeginBlockThreads();
2828 data = new wxPyUserData(userData);
2829 wxPyEndBlockThreads(blocked);
2830 }
2831 return new wxSizerItem(sizer, proportion, flag, border, data);
2832 }
2833
2834 #include <float.h>
2835 SWIGINTERN int
2836 SWIG_CheckDoubleInRange(double value, double min_value,
2837 double max_value, const char* errmsg)
2838 {
2839 if (value < min_value) {
2840 if (errmsg) {
2841 PyErr_Format(PyExc_OverflowError,
2842 "value %g is less than %s minimum %g",
2843 value, errmsg, min_value);
2844 }
2845 return 0;
2846 } else if (value > max_value) {
2847 if (errmsg) {
2848 PyErr_Format(PyExc_OverflowError,
2849 "value %g is greater than %s maximum %g",
2850 value, errmsg, max_value);
2851 }
2852 return 0;
2853 }
2854 return 1;
2855 }
2856
2857
2858 SWIGINTERN int
2859 SWIG_AsVal_float(PyObject *obj, float *val)
2860 {
2861 const char* errmsg = val ? "float" : (char*)0;
2862 double v;
2863 if (SWIG_AsVal_double(obj, &v)) {
2864 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2865 if (val) *val = (float)(v);
2866 return 1;
2867 } else {
2868 return 0;
2869 }
2870 } else {
2871 PyErr_Clear();
2872 }
2873 if (val) {
2874 SWIG_type_error(errmsg, obj);
2875 }
2876 return 0;
2877 }
2878
2879
2880 SWIGINTERNSHORT float
2881 SWIG_As_float(PyObject* obj)
2882 {
2883 float v;
2884 if (!SWIG_AsVal_float(obj, &v)) {
2885 /*
2886 this is needed to make valgrind/purify happier.
2887 */
2888 memset((void*)&v, 0, sizeof(float));
2889 }
2890 return v;
2891 }
2892
2893
2894 SWIGINTERNSHORT int
2895 SWIG_Check_float(PyObject* obj)
2896 {
2897 return SWIG_AsVal_float(obj, (float*)0);
2898 }
2899
2900
2901 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2902 #define SWIG_From_float PyFloat_FromDouble
2903 /*@@*/
2904
2905 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2906 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2907 if (data) {
2908 Py_INCREF(data->m_obj);
2909 return data->m_obj;
2910 } else {
2911 Py_INCREF(Py_None);
2912 return Py_None;
2913 }
2914 }
2915
2916 // Figure out the type of the sizer item
2917
2918 struct wxPySizerItemInfo {
2919 wxPySizerItemInfo()
2920 : window(NULL), sizer(NULL), gotSize(false),
2921 size(wxDefaultSize), gotPos(false), pos(-1)
2922 {}
2923
2924 wxWindow* window;
2925 wxSizer* sizer;
2926 bool gotSize;
2927 wxSize size;
2928 bool gotPos;
2929 int pos;
2930 };
2931
2932 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2933
2934 wxPySizerItemInfo info;
2935 wxSize size;
2936 wxSize* sizePtr = &size;
2937
2938 // Find out what the type of the item is
2939 // try wxWindow
2940 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2941 PyErr_Clear();
2942 info.window = NULL;
2943
2944 // try wxSizer
2945 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2946 PyErr_Clear();
2947 info.sizer = NULL;
2948
2949 // try wxSize or (w,h)
2950 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2951 info.size = *sizePtr;
2952 info.gotSize = true;
2953 }
2954
2955 // or a single int
2956 if (checkIdx && PyInt_Check(item)) {
2957 info.pos = PyInt_AsLong(item);
2958 info.gotPos = true;
2959 }
2960 }
2961 }
2962
2963 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2964 // no expected type, figure out what kind of error message to generate
2965 if ( !checkSize && !checkIdx )
2966 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2967 else if ( checkSize && !checkIdx )
2968 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2969 else if ( !checkSize && checkIdx)
2970 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2971 else
2972 // can this one happen?
2973 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2974 }
2975
2976 return info;
2977 }
2978
2979 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2980 if (!self->GetClientObject())
2981 self->SetClientObject(new wxPyOORClientData(_self));
2982 }
2983 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2984
2985 wxPyUserData* data = NULL;
2986 bool blocked = wxPyBeginBlockThreads();
2987 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2988 if ( userData && (info.window || info.sizer || info.gotSize) )
2989 data = new wxPyUserData(userData);
2990 wxPyEndBlockThreads(blocked);
2991
2992 // Now call the real Add method if a valid item type was found
2993 if ( info.window )
2994 return self->Add(info.window, proportion, flag, border, data);
2995 else if ( info.sizer )
2996 return self->Add(info.sizer, proportion, flag, border, data);
2997 else if (info.gotSize)
2998 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2999 proportion, flag, border, data);
3000 else
3001 return NULL;
3002 }
3003 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3004
3005 wxPyUserData* data = NULL;
3006 bool blocked = wxPyBeginBlockThreads();
3007 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3008 if ( userData && (info.window || info.sizer || info.gotSize) )
3009 data = new wxPyUserData(userData);
3010 wxPyEndBlockThreads(blocked);
3011
3012 // Now call the real Insert method if a valid item type was found
3013 if ( info.window )
3014 return self->Insert(before, info.window, proportion, flag, border, data);
3015 else if ( info.sizer )
3016 return self->Insert(before, info.sizer, proportion, flag, border, data);
3017 else if (info.gotSize)
3018 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3019 proportion, flag, border, data);
3020 else
3021 return NULL;
3022 }
3023 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3024
3025 wxPyUserData* data = NULL;
3026 bool blocked = wxPyBeginBlockThreads();
3027 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3028 if ( userData && (info.window || info.sizer || info.gotSize) )
3029 data = new wxPyUserData(userData);
3030 wxPyEndBlockThreads(blocked);
3031
3032 // Now call the real Prepend method if a valid item type was found
3033 if ( info.window )
3034 return self->Prepend(info.window, proportion, flag, border, data);
3035 else if ( info.sizer )
3036 return self->Prepend(info.sizer, proportion, flag, border, data);
3037 else if (info.gotSize)
3038 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3039 proportion, flag, border, data);
3040 else
3041 return NULL;
3042 }
3043 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3044 bool blocked = wxPyBeginBlockThreads();
3045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3046 wxPyEndBlockThreads(blocked);
3047 if ( info.window )
3048 return self->Remove(info.window);
3049 else if ( info.sizer )
3050 return self->Remove(info.sizer);
3051 else if ( info.gotPos )
3052 return self->Remove(info.pos);
3053 else
3054 return false;
3055 }
3056 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3057 bool blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 return self->Detach(info.window);
3062 else if ( info.sizer )
3063 return self->Detach(info.sizer);
3064 else if ( info.gotPos )
3065 return self->Detach(info.pos);
3066 else
3067 return false;
3068 }
3069 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3070 bool blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 return self->GetItem(info.window);
3075 else if ( info.sizer )
3076 return self->GetItem(info.sizer);
3077 else if ( info.gotPos )
3078 return self->GetItem(info.pos);
3079 else
3080 return NULL;
3081 }
3082 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3083 bool blocked = wxPyBeginBlockThreads();
3084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3085 wxPyEndBlockThreads(blocked);
3086 if ( info.window )
3087 self->SetItemMinSize(info.window, size);
3088 else if ( info.sizer )
3089 self->SetItemMinSize(info.sizer, size);
3090 else if ( info.gotPos )
3091 self->SetItemMinSize(info.pos, size);
3092 }
3093 static PyObject *wxSizer_GetChildren(wxSizer *self){
3094 wxSizerItemList& list = self->GetChildren();
3095 return wxPy_ConvertList(&list);
3096 }
3097 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3098 bool blocked = wxPyBeginBlockThreads();
3099 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3100 wxPyEndBlockThreads(blocked);
3101 if ( info.window )
3102 return self->Show(info.window, show, recursive);
3103 else if ( info.sizer )
3104 return self->Show(info.sizer, show, recursive);
3105 else if ( info.gotPos )
3106 return self->Show(info.pos, show);
3107 else
3108 return false;
3109 }
3110 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3111 bool blocked = wxPyBeginBlockThreads();
3112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3113 wxPyEndBlockThreads(blocked);
3114 if ( info.window )
3115 return self->IsShown(info.window);
3116 else if ( info.sizer )
3117 return self->IsShown(info.sizer);
3118 else if ( info.gotPos )
3119 return self->IsShown(info.pos);
3120 else
3121 return false;
3122 }
3123
3124 // See pyclasses.h
3125 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3126 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3127 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3128
3129
3130
3131
3132 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3133 {
3134 if (source == Py_None) {
3135 **obj = wxGBPosition(-1,-1);
3136 return true;
3137 }
3138 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3139 }
3140
3141 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3142 {
3143 if (source == Py_None) {
3144 **obj = wxGBSpan(-1,-1);
3145 return true;
3146 }
3147 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3148 }
3149
3150
3151 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3152 self->SetRow(row);
3153 self->SetCol(col);
3154 }
3155 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3156 bool blocked = wxPyBeginBlockThreads();
3157 PyObject* tup = PyTuple_New(2);
3158 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3159 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3160 wxPyEndBlockThreads(blocked);
3161 return tup;
3162 }
3163 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3164 self->SetRowspan(rowspan);
3165 self->SetColspan(colspan);
3166 }
3167 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3168 bool blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3171 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3172 wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3176 wxPyUserData* data = NULL;
3177 if ( userData ) {
3178 bool blocked = wxPyBeginBlockThreads();
3179 data = new wxPyUserData(userData);
3180 wxPyEndBlockThreads(blocked);
3181 }
3182 return new wxGBSizerItem(window, pos, span, flag, border, data);
3183 }
3184 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3185 wxPyUserData* data = NULL;
3186 if ( userData ) {
3187 bool blocked = wxPyBeginBlockThreads();
3188 data = new wxPyUserData(userData);
3189 wxPyEndBlockThreads(blocked);
3190 }
3191 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3192 }
3193 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3194 wxPyUserData* data = NULL;
3195 if ( userData ) {
3196 bool blocked = wxPyBeginBlockThreads();
3197 data = new wxPyUserData(userData);
3198 wxPyEndBlockThreads(blocked);
3199 }
3200 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3201 }
3202 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3203 int row, col;
3204 self->GetEndPos(row, col);
3205 return wxGBPosition(row, col);
3206 }
3207 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3208
3209 wxPyUserData* data = NULL;
3210 bool blocked = wxPyBeginBlockThreads();
3211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3212 if ( userData && (info.window || info.sizer || info.gotSize) )
3213 data = new wxPyUserData(userData);
3214 wxPyEndBlockThreads(blocked);
3215
3216 // Now call the real Add method if a valid item type was found
3217 if ( info.window )
3218 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3219 else if ( info.sizer )
3220 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3221 else if (info.gotSize)
3222 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3223 pos, span, flag, border, data);
3224 return NULL;
3225 }
3226
3227
3228 #ifdef __cplusplus
3229 extern "C" {
3230 #endif
3231 static int _wrap_EmptyString_set(PyObject *) {
3232 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3233 return 1;
3234 }
3235
3236
3237 static PyObject *_wrap_EmptyString_get(void) {
3238 PyObject *pyobj;
3239
3240 {
3241 #if wxUSE_UNICODE
3242 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3243 #else
3244 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3245 #endif
3246 }
3247 return pyobj;
3248 }
3249
3250
3251 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3252 PyObject *resultobj;
3253 wxObject *arg1 = (wxObject *) 0 ;
3254 wxString result;
3255 PyObject * obj0 = 0 ;
3256 char *kwnames[] = {
3257 (char *) "self", NULL
3258 };
3259
3260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3262 if (SWIG_arg_fail(1)) SWIG_fail;
3263 {
3264 PyThreadState* __tstate = wxPyBeginAllowThreads();
3265 result = wxObject_GetClassName(arg1);
3266
3267 wxPyEndAllowThreads(__tstate);
3268 if (PyErr_Occurred()) SWIG_fail;
3269 }
3270 {
3271 #if wxUSE_UNICODE
3272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3273 #else
3274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3275 #endif
3276 }
3277 return resultobj;
3278 fail:
3279 return NULL;
3280 }
3281
3282
3283 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3284 PyObject *resultobj;
3285 wxObject *arg1 = (wxObject *) 0 ;
3286 PyObject * obj0 = 0 ;
3287 char *kwnames[] = {
3288 (char *) "self", NULL
3289 };
3290
3291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3293 if (SWIG_arg_fail(1)) SWIG_fail;
3294 {
3295 PyThreadState* __tstate = wxPyBeginAllowThreads();
3296 wxObject_Destroy(arg1);
3297
3298 wxPyEndAllowThreads(__tstate);
3299 if (PyErr_Occurred()) SWIG_fail;
3300 }
3301 Py_INCREF(Py_None); resultobj = Py_None;
3302 return resultobj;
3303 fail:
3304 return NULL;
3305 }
3306
3307
3308 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3309 PyObject *obj;
3310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3311 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3312 Py_INCREF(obj);
3313 return Py_BuildValue((char *)"");
3314 }
3315 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3316 PyObject *resultobj;
3317 wxSize *arg1 = (wxSize *) 0 ;
3318 int arg2 ;
3319 PyObject * obj0 = 0 ;
3320 PyObject * obj1 = 0 ;
3321 char *kwnames[] = {
3322 (char *) "self",(char *) "x", NULL
3323 };
3324
3325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3327 if (SWIG_arg_fail(1)) SWIG_fail;
3328 {
3329 arg2 = (int)(SWIG_As_int(obj1));
3330 if (SWIG_arg_fail(2)) SWIG_fail;
3331 }
3332 if (arg1) (arg1)->x = arg2;
3333
3334 Py_INCREF(Py_None); resultobj = Py_None;
3335 return resultobj;
3336 fail:
3337 return NULL;
3338 }
3339
3340
3341 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3342 PyObject *resultobj;
3343 wxSize *arg1 = (wxSize *) 0 ;
3344 int result;
3345 PyObject * obj0 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 result = (int) ((arg1)->x);
3354
3355 {
3356 resultobj = SWIG_From_int((int)(result));
3357 }
3358 return resultobj;
3359 fail:
3360 return NULL;
3361 }
3362
3363
3364 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3365 PyObject *resultobj;
3366 wxSize *arg1 = (wxSize *) 0 ;
3367 int arg2 ;
3368 PyObject * obj0 = 0 ;
3369 PyObject * obj1 = 0 ;
3370 char *kwnames[] = {
3371 (char *) "self",(char *) "y", NULL
3372 };
3373
3374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3376 if (SWIG_arg_fail(1)) SWIG_fail;
3377 {
3378 arg2 = (int)(SWIG_As_int(obj1));
3379 if (SWIG_arg_fail(2)) SWIG_fail;
3380 }
3381 if (arg1) (arg1)->y = arg2;
3382
3383 Py_INCREF(Py_None); resultobj = Py_None;
3384 return resultobj;
3385 fail:
3386 return NULL;
3387 }
3388
3389
3390 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3391 PyObject *resultobj;
3392 wxSize *arg1 = (wxSize *) 0 ;
3393 int result;
3394 PyObject * obj0 = 0 ;
3395 char *kwnames[] = {
3396 (char *) "self", NULL
3397 };
3398
3399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3401 if (SWIG_arg_fail(1)) SWIG_fail;
3402 result = (int) ((arg1)->y);
3403
3404 {
3405 resultobj = SWIG_From_int((int)(result));
3406 }
3407 return resultobj;
3408 fail:
3409 return NULL;
3410 }
3411
3412
3413 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3414 PyObject *resultobj;
3415 int arg1 = (int) 0 ;
3416 int arg2 = (int) 0 ;
3417 wxSize *result;
3418 PyObject * obj0 = 0 ;
3419 PyObject * obj1 = 0 ;
3420 char *kwnames[] = {
3421 (char *) "w",(char *) "h", NULL
3422 };
3423
3424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3425 if (obj0) {
3426 {
3427 arg1 = (int)(SWIG_As_int(obj0));
3428 if (SWIG_arg_fail(1)) SWIG_fail;
3429 }
3430 }
3431 if (obj1) {
3432 {
3433 arg2 = (int)(SWIG_As_int(obj1));
3434 if (SWIG_arg_fail(2)) SWIG_fail;
3435 }
3436 }
3437 {
3438 PyThreadState* __tstate = wxPyBeginAllowThreads();
3439 result = (wxSize *)new wxSize(arg1,arg2);
3440
3441 wxPyEndAllowThreads(__tstate);
3442 if (PyErr_Occurred()) SWIG_fail;
3443 }
3444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3445 return resultobj;
3446 fail:
3447 return NULL;
3448 }
3449
3450
3451 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj;
3453 wxSize *arg1 = (wxSize *) 0 ;
3454 PyObject * obj0 = 0 ;
3455 char *kwnames[] = {
3456 (char *) "self", NULL
3457 };
3458
3459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3461 if (SWIG_arg_fail(1)) SWIG_fail;
3462 {
3463 PyThreadState* __tstate = wxPyBeginAllowThreads();
3464 delete arg1;
3465
3466 wxPyEndAllowThreads(__tstate);
3467 if (PyErr_Occurred()) SWIG_fail;
3468 }
3469 Py_INCREF(Py_None); resultobj = Py_None;
3470 return resultobj;
3471 fail:
3472 return NULL;
3473 }
3474
3475
3476 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3477 PyObject *resultobj;
3478 wxSize *arg1 = (wxSize *) 0 ;
3479 wxSize *arg2 = 0 ;
3480 bool result;
3481 wxSize temp2 ;
3482 PyObject * obj0 = 0 ;
3483 PyObject * obj1 = 0 ;
3484 char *kwnames[] = {
3485 (char *) "self",(char *) "sz", NULL
3486 };
3487
3488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3490 if (SWIG_arg_fail(1)) SWIG_fail;
3491 {
3492 arg2 = &temp2;
3493 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3494 }
3495 {
3496 PyThreadState* __tstate = wxPyBeginAllowThreads();
3497 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3498
3499 wxPyEndAllowThreads(__tstate);
3500 if (PyErr_Occurred()) SWIG_fail;
3501 }
3502 {
3503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3504 }
3505 return resultobj;
3506 fail:
3507 return NULL;
3508 }
3509
3510
3511 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3512 PyObject *resultobj;
3513 wxSize *arg1 = (wxSize *) 0 ;
3514 wxSize *arg2 = 0 ;
3515 bool result;
3516 wxSize temp2 ;
3517 PyObject * obj0 = 0 ;
3518 PyObject * obj1 = 0 ;
3519 char *kwnames[] = {
3520 (char *) "self",(char *) "sz", NULL
3521 };
3522
3523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3525 if (SWIG_arg_fail(1)) SWIG_fail;
3526 {
3527 arg2 = &temp2;
3528 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3529 }
3530 {
3531 PyThreadState* __tstate = wxPyBeginAllowThreads();
3532 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3533
3534 wxPyEndAllowThreads(__tstate);
3535 if (PyErr_Occurred()) SWIG_fail;
3536 }
3537 {
3538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3539 }
3540 return resultobj;
3541 fail:
3542 return NULL;
3543 }
3544
3545
3546 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3547 PyObject *resultobj;
3548 wxSize *arg1 = (wxSize *) 0 ;
3549 wxSize *arg2 = 0 ;
3550 wxSize result;
3551 wxSize temp2 ;
3552 PyObject * obj0 = 0 ;
3553 PyObject * obj1 = 0 ;
3554 char *kwnames[] = {
3555 (char *) "self",(char *) "sz", NULL
3556 };
3557
3558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3560 if (SWIG_arg_fail(1)) SWIG_fail;
3561 {
3562 arg2 = &temp2;
3563 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3564 }
3565 {
3566 PyThreadState* __tstate = wxPyBeginAllowThreads();
3567 result = (arg1)->operator +((wxSize const &)*arg2);
3568
3569 wxPyEndAllowThreads(__tstate);
3570 if (PyErr_Occurred()) SWIG_fail;
3571 }
3572 {
3573 wxSize * resultptr;
3574 resultptr = new wxSize((wxSize &)(result));
3575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3576 }
3577 return resultobj;
3578 fail:
3579 return NULL;
3580 }
3581
3582
3583 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3584 PyObject *resultobj;
3585 wxSize *arg1 = (wxSize *) 0 ;
3586 wxSize *arg2 = 0 ;
3587 wxSize result;
3588 wxSize temp2 ;
3589 PyObject * obj0 = 0 ;
3590 PyObject * obj1 = 0 ;
3591 char *kwnames[] = {
3592 (char *) "self",(char *) "sz", NULL
3593 };
3594
3595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3597 if (SWIG_arg_fail(1)) SWIG_fail;
3598 {
3599 arg2 = &temp2;
3600 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3601 }
3602 {
3603 PyThreadState* __tstate = wxPyBeginAllowThreads();
3604 result = (arg1)->operator -((wxSize const &)*arg2);
3605
3606 wxPyEndAllowThreads(__tstate);
3607 if (PyErr_Occurred()) SWIG_fail;
3608 }
3609 {
3610 wxSize * resultptr;
3611 resultptr = new wxSize((wxSize &)(result));
3612 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3613 }
3614 return resultobj;
3615 fail:
3616 return NULL;
3617 }
3618
3619
3620 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3621 PyObject *resultobj;
3622 wxSize *arg1 = (wxSize *) 0 ;
3623 wxSize *arg2 = 0 ;
3624 wxSize temp2 ;
3625 PyObject * obj0 = 0 ;
3626 PyObject * obj1 = 0 ;
3627 char *kwnames[] = {
3628 (char *) "self",(char *) "sz", NULL
3629 };
3630
3631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3633 if (SWIG_arg_fail(1)) SWIG_fail;
3634 {
3635 arg2 = &temp2;
3636 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3637 }
3638 {
3639 PyThreadState* __tstate = wxPyBeginAllowThreads();
3640 (arg1)->IncTo((wxSize const &)*arg2);
3641
3642 wxPyEndAllowThreads(__tstate);
3643 if (PyErr_Occurred()) SWIG_fail;
3644 }
3645 Py_INCREF(Py_None); resultobj = Py_None;
3646 return resultobj;
3647 fail:
3648 return NULL;
3649 }
3650
3651
3652 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3653 PyObject *resultobj;
3654 wxSize *arg1 = (wxSize *) 0 ;
3655 wxSize *arg2 = 0 ;
3656 wxSize temp2 ;
3657 PyObject * obj0 = 0 ;
3658 PyObject * obj1 = 0 ;
3659 char *kwnames[] = {
3660 (char *) "self",(char *) "sz", NULL
3661 };
3662
3663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3665 if (SWIG_arg_fail(1)) SWIG_fail;
3666 {
3667 arg2 = &temp2;
3668 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3669 }
3670 {
3671 PyThreadState* __tstate = wxPyBeginAllowThreads();
3672 (arg1)->DecTo((wxSize const &)*arg2);
3673
3674 wxPyEndAllowThreads(__tstate);
3675 if (PyErr_Occurred()) SWIG_fail;
3676 }
3677 Py_INCREF(Py_None); resultobj = Py_None;
3678 return resultobj;
3679 fail:
3680 return NULL;
3681 }
3682
3683
3684 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3685 PyObject *resultobj;
3686 wxSize *arg1 = (wxSize *) 0 ;
3687 int arg2 ;
3688 int arg3 ;
3689 PyObject * obj0 = 0 ;
3690 PyObject * obj1 = 0 ;
3691 PyObject * obj2 = 0 ;
3692 char *kwnames[] = {
3693 (char *) "self",(char *) "w",(char *) "h", NULL
3694 };
3695
3696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3698 if (SWIG_arg_fail(1)) SWIG_fail;
3699 {
3700 arg2 = (int)(SWIG_As_int(obj1));
3701 if (SWIG_arg_fail(2)) SWIG_fail;
3702 }
3703 {
3704 arg3 = (int)(SWIG_As_int(obj2));
3705 if (SWIG_arg_fail(3)) SWIG_fail;
3706 }
3707 {
3708 PyThreadState* __tstate = wxPyBeginAllowThreads();
3709 (arg1)->Set(arg2,arg3);
3710
3711 wxPyEndAllowThreads(__tstate);
3712 if (PyErr_Occurred()) SWIG_fail;
3713 }
3714 Py_INCREF(Py_None); resultobj = Py_None;
3715 return resultobj;
3716 fail:
3717 return NULL;
3718 }
3719
3720
3721 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3722 PyObject *resultobj;
3723 wxSize *arg1 = (wxSize *) 0 ;
3724 int arg2 ;
3725 PyObject * obj0 = 0 ;
3726 PyObject * obj1 = 0 ;
3727 char *kwnames[] = {
3728 (char *) "self",(char *) "w", NULL
3729 };
3730
3731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3733 if (SWIG_arg_fail(1)) SWIG_fail;
3734 {
3735 arg2 = (int)(SWIG_As_int(obj1));
3736 if (SWIG_arg_fail(2)) SWIG_fail;
3737 }
3738 {
3739 PyThreadState* __tstate = wxPyBeginAllowThreads();
3740 (arg1)->SetWidth(arg2);
3741
3742 wxPyEndAllowThreads(__tstate);
3743 if (PyErr_Occurred()) SWIG_fail;
3744 }
3745 Py_INCREF(Py_None); resultobj = Py_None;
3746 return resultobj;
3747 fail:
3748 return NULL;
3749 }
3750
3751
3752 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3753 PyObject *resultobj;
3754 wxSize *arg1 = (wxSize *) 0 ;
3755 int arg2 ;
3756 PyObject * obj0 = 0 ;
3757 PyObject * obj1 = 0 ;
3758 char *kwnames[] = {
3759 (char *) "self",(char *) "h", NULL
3760 };
3761
3762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3764 if (SWIG_arg_fail(1)) SWIG_fail;
3765 {
3766 arg2 = (int)(SWIG_As_int(obj1));
3767 if (SWIG_arg_fail(2)) SWIG_fail;
3768 }
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 (arg1)->SetHeight(arg2);
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 Py_INCREF(Py_None); resultobj = Py_None;
3777 return resultobj;
3778 fail:
3779 return NULL;
3780 }
3781
3782
3783 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3784 PyObject *resultobj;
3785 wxSize *arg1 = (wxSize *) 0 ;
3786 int result;
3787 PyObject * obj0 = 0 ;
3788 char *kwnames[] = {
3789 (char *) "self", NULL
3790 };
3791
3792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3794 if (SWIG_arg_fail(1)) SWIG_fail;
3795 {
3796 PyThreadState* __tstate = wxPyBeginAllowThreads();
3797 result = (int)((wxSize const *)arg1)->GetWidth();
3798
3799 wxPyEndAllowThreads(__tstate);
3800 if (PyErr_Occurred()) SWIG_fail;
3801 }
3802 {
3803 resultobj = SWIG_From_int((int)(result));
3804 }
3805 return resultobj;
3806 fail:
3807 return NULL;
3808 }
3809
3810
3811 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3812 PyObject *resultobj;
3813 wxSize *arg1 = (wxSize *) 0 ;
3814 int result;
3815 PyObject * obj0 = 0 ;
3816 char *kwnames[] = {
3817 (char *) "self", NULL
3818 };
3819
3820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3822 if (SWIG_arg_fail(1)) SWIG_fail;
3823 {
3824 PyThreadState* __tstate = wxPyBeginAllowThreads();
3825 result = (int)((wxSize const *)arg1)->GetHeight();
3826
3827 wxPyEndAllowThreads(__tstate);
3828 if (PyErr_Occurred()) SWIG_fail;
3829 }
3830 {
3831 resultobj = SWIG_From_int((int)(result));
3832 }
3833 return resultobj;
3834 fail:
3835 return NULL;
3836 }
3837
3838
3839 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3840 PyObject *resultobj;
3841 wxSize *arg1 = (wxSize *) 0 ;
3842 bool result;
3843 PyObject * obj0 = 0 ;
3844 char *kwnames[] = {
3845 (char *) "self", NULL
3846 };
3847
3848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3850 if (SWIG_arg_fail(1)) SWIG_fail;
3851 {
3852 PyThreadState* __tstate = wxPyBeginAllowThreads();
3853 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3854
3855 wxPyEndAllowThreads(__tstate);
3856 if (PyErr_Occurred()) SWIG_fail;
3857 }
3858 {
3859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3860 }
3861 return resultobj;
3862 fail:
3863 return NULL;
3864 }
3865
3866
3867 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3868 PyObject *resultobj;
3869 wxSize *arg1 = (wxSize *) 0 ;
3870 wxSize *arg2 = 0 ;
3871 wxSize temp2 ;
3872 PyObject * obj0 = 0 ;
3873 PyObject * obj1 = 0 ;
3874 char *kwnames[] = {
3875 (char *) "self",(char *) "size", NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3880 if (SWIG_arg_fail(1)) SWIG_fail;
3881 {
3882 arg2 = &temp2;
3883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3884 }
3885 {
3886 PyThreadState* __tstate = wxPyBeginAllowThreads();
3887 (arg1)->SetDefaults((wxSize const &)*arg2);
3888
3889 wxPyEndAllowThreads(__tstate);
3890 if (PyErr_Occurred()) SWIG_fail;
3891 }
3892 Py_INCREF(Py_None); resultobj = Py_None;
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3900 PyObject *resultobj;
3901 wxSize *arg1 = (wxSize *) 0 ;
3902 PyObject *result;
3903 PyObject * obj0 = 0 ;
3904 char *kwnames[] = {
3905 (char *) "self", NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3910 if (SWIG_arg_fail(1)) SWIG_fail;
3911 {
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 result = (PyObject *)wxSize_Get(arg1);
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 resultobj = result;
3919 return resultobj;
3920 fail:
3921 return NULL;
3922 }
3923
3924
3925 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3926 PyObject *obj;
3927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3928 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3929 Py_INCREF(obj);
3930 return Py_BuildValue((char *)"");
3931 }
3932 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3933 PyObject *resultobj;
3934 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3935 double arg2 ;
3936 PyObject * obj0 = 0 ;
3937 PyObject * obj1 = 0 ;
3938 char *kwnames[] = {
3939 (char *) "self",(char *) "x", NULL
3940 };
3941
3942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3944 if (SWIG_arg_fail(1)) SWIG_fail;
3945 {
3946 arg2 = (double)(SWIG_As_double(obj1));
3947 if (SWIG_arg_fail(2)) SWIG_fail;
3948 }
3949 if (arg1) (arg1)->x = arg2;
3950
3951 Py_INCREF(Py_None); resultobj = Py_None;
3952 return resultobj;
3953 fail:
3954 return NULL;
3955 }
3956
3957
3958 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3959 PyObject *resultobj;
3960 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3961 double result;
3962 PyObject * obj0 = 0 ;
3963 char *kwnames[] = {
3964 (char *) "self", NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3969 if (SWIG_arg_fail(1)) SWIG_fail;
3970 result = (double) ((arg1)->x);
3971
3972 {
3973 resultobj = SWIG_From_double((double)(result));
3974 }
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj;
3983 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3984 double arg2 ;
3985 PyObject * obj0 = 0 ;
3986 PyObject * obj1 = 0 ;
3987 char *kwnames[] = {
3988 (char *) "self",(char *) "y", NULL
3989 };
3990
3991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3993 if (SWIG_arg_fail(1)) SWIG_fail;
3994 {
3995 arg2 = (double)(SWIG_As_double(obj1));
3996 if (SWIG_arg_fail(2)) SWIG_fail;
3997 }
3998 if (arg1) (arg1)->y = arg2;
3999
4000 Py_INCREF(Py_None); resultobj = Py_None;
4001 return resultobj;
4002 fail:
4003 return NULL;
4004 }
4005
4006
4007 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4008 PyObject *resultobj;
4009 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4010 double result;
4011 PyObject * obj0 = 0 ;
4012 char *kwnames[] = {
4013 (char *) "self", NULL
4014 };
4015
4016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4018 if (SWIG_arg_fail(1)) SWIG_fail;
4019 result = (double) ((arg1)->y);
4020
4021 {
4022 resultobj = SWIG_From_double((double)(result));
4023 }
4024 return resultobj;
4025 fail:
4026 return NULL;
4027 }
4028
4029
4030 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj;
4032 double arg1 = (double) 0.0 ;
4033 double arg2 = (double) 0.0 ;
4034 wxRealPoint *result;
4035 PyObject * obj0 = 0 ;
4036 PyObject * obj1 = 0 ;
4037 char *kwnames[] = {
4038 (char *) "x",(char *) "y", NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4042 if (obj0) {
4043 {
4044 arg1 = (double)(SWIG_As_double(obj0));
4045 if (SWIG_arg_fail(1)) SWIG_fail;
4046 }
4047 }
4048 if (obj1) {
4049 {
4050 arg2 = (double)(SWIG_As_double(obj1));
4051 if (SWIG_arg_fail(2)) SWIG_fail;
4052 }
4053 }
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4062 return resultobj;
4063 fail:
4064 return NULL;
4065 }
4066
4067
4068 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4069 PyObject *resultobj;
4070 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4071 PyObject * obj0 = 0 ;
4072 char *kwnames[] = {
4073 (char *) "self", NULL
4074 };
4075
4076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4078 if (SWIG_arg_fail(1)) SWIG_fail;
4079 {
4080 PyThreadState* __tstate = wxPyBeginAllowThreads();
4081 delete arg1;
4082
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 Py_INCREF(Py_None); resultobj = Py_None;
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4096 wxRealPoint *arg2 = 0 ;
4097 bool result;
4098 wxRealPoint temp2 ;
4099 PyObject * obj0 = 0 ;
4100 PyObject * obj1 = 0 ;
4101 char *kwnames[] = {
4102 (char *) "self",(char *) "pt", NULL
4103 };
4104
4105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4107 if (SWIG_arg_fail(1)) SWIG_fail;
4108 {
4109 arg2 = &temp2;
4110 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4111 }
4112 {
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4115
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 {
4120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4121 }
4122 return resultobj;
4123 fail:
4124 return NULL;
4125 }
4126
4127
4128 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4129 PyObject *resultobj;
4130 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4131 wxRealPoint *arg2 = 0 ;
4132 bool result;
4133 wxRealPoint temp2 ;
4134 PyObject * obj0 = 0 ;
4135 PyObject * obj1 = 0 ;
4136 char *kwnames[] = {
4137 (char *) "self",(char *) "pt", NULL
4138 };
4139
4140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4142 if (SWIG_arg_fail(1)) SWIG_fail;
4143 {
4144 arg2 = &temp2;
4145 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4146 }
4147 {
4148 PyThreadState* __tstate = wxPyBeginAllowThreads();
4149 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4150
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 {
4155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4156 }
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4164 PyObject *resultobj;
4165 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4166 wxRealPoint *arg2 = 0 ;
4167 wxRealPoint result;
4168 wxRealPoint temp2 ;
4169 PyObject * obj0 = 0 ;
4170 PyObject * obj1 = 0 ;
4171 char *kwnames[] = {
4172 (char *) "self",(char *) "pt", NULL
4173 };
4174
4175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4177 if (SWIG_arg_fail(1)) SWIG_fail;
4178 {
4179 arg2 = &temp2;
4180 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4181 }
4182 {
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4185
4186 wxPyEndAllowThreads(__tstate);
4187 if (PyErr_Occurred()) SWIG_fail;
4188 }
4189 {
4190 wxRealPoint * resultptr;
4191 resultptr = new wxRealPoint((wxRealPoint &)(result));
4192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4193 }
4194 return resultobj;
4195 fail:
4196 return NULL;
4197 }
4198
4199
4200 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4201 PyObject *resultobj;
4202 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4203 wxRealPoint *arg2 = 0 ;
4204 wxRealPoint result;
4205 wxRealPoint temp2 ;
4206 PyObject * obj0 = 0 ;
4207 PyObject * obj1 = 0 ;
4208 char *kwnames[] = {
4209 (char *) "self",(char *) "pt", NULL
4210 };
4211
4212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4214 if (SWIG_arg_fail(1)) SWIG_fail;
4215 {
4216 arg2 = &temp2;
4217 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4218 }
4219 {
4220 PyThreadState* __tstate = wxPyBeginAllowThreads();
4221 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4222
4223 wxPyEndAllowThreads(__tstate);
4224 if (PyErr_Occurred()) SWIG_fail;
4225 }
4226 {
4227 wxRealPoint * resultptr;
4228 resultptr = new wxRealPoint((wxRealPoint &)(result));
4229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4230 }
4231 return resultobj;
4232 fail:
4233 return NULL;
4234 }
4235
4236
4237 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4238 PyObject *resultobj;
4239 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4240 double arg2 ;
4241 double arg3 ;
4242 PyObject * obj0 = 0 ;
4243 PyObject * obj1 = 0 ;
4244 PyObject * obj2 = 0 ;
4245 char *kwnames[] = {
4246 (char *) "self",(char *) "x",(char *) "y", NULL
4247 };
4248
4249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4251 if (SWIG_arg_fail(1)) SWIG_fail;
4252 {
4253 arg2 = (double)(SWIG_As_double(obj1));
4254 if (SWIG_arg_fail(2)) SWIG_fail;
4255 }
4256 {
4257 arg3 = (double)(SWIG_As_double(obj2));
4258 if (SWIG_arg_fail(3)) SWIG_fail;
4259 }
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 wxRealPoint_Set(arg1,arg2,arg3);
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 Py_INCREF(Py_None); resultobj = Py_None;
4268 return resultobj;
4269 fail:
4270 return NULL;
4271 }
4272
4273
4274 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4275 PyObject *resultobj;
4276 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4277 PyObject *result;
4278 PyObject * obj0 = 0 ;
4279 char *kwnames[] = {
4280 (char *) "self", NULL
4281 };
4282
4283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4285 if (SWIG_arg_fail(1)) SWIG_fail;
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 result = (PyObject *)wxRealPoint_Get(arg1);
4289
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 resultobj = result;
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4301 PyObject *obj;
4302 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4303 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4304 Py_INCREF(obj);
4305 return Py_BuildValue((char *)"");
4306 }
4307 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4308 PyObject *resultobj;
4309 wxPoint *arg1 = (wxPoint *) 0 ;
4310 int arg2 ;
4311 PyObject * obj0 = 0 ;
4312 PyObject * obj1 = 0 ;
4313 char *kwnames[] = {
4314 (char *) "self",(char *) "x", NULL
4315 };
4316
4317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4319 if (SWIG_arg_fail(1)) SWIG_fail;
4320 {
4321 arg2 = (int)(SWIG_As_int(obj1));
4322 if (SWIG_arg_fail(2)) SWIG_fail;
4323 }
4324 if (arg1) (arg1)->x = arg2;
4325
4326 Py_INCREF(Py_None); resultobj = Py_None;
4327 return resultobj;
4328 fail:
4329 return NULL;
4330 }
4331
4332
4333 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4334 PyObject *resultobj;
4335 wxPoint *arg1 = (wxPoint *) 0 ;
4336 int result;
4337 PyObject * obj0 = 0 ;
4338 char *kwnames[] = {
4339 (char *) "self", NULL
4340 };
4341
4342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4344 if (SWIG_arg_fail(1)) SWIG_fail;
4345 result = (int) ((arg1)->x);
4346
4347 {
4348 resultobj = SWIG_From_int((int)(result));
4349 }
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxPoint *arg1 = (wxPoint *) 0 ;
4359 int arg2 ;
4360 PyObject * obj0 = 0 ;
4361 PyObject * obj1 = 0 ;
4362 char *kwnames[] = {
4363 (char *) "self",(char *) "y", NULL
4364 };
4365
4366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4368 if (SWIG_arg_fail(1)) SWIG_fail;
4369 {
4370 arg2 = (int)(SWIG_As_int(obj1));
4371 if (SWIG_arg_fail(2)) SWIG_fail;
4372 }
4373 if (arg1) (arg1)->y = arg2;
4374
4375 Py_INCREF(Py_None); resultobj = Py_None;
4376 return resultobj;
4377 fail:
4378 return NULL;
4379 }
4380
4381
4382 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj;
4384 wxPoint *arg1 = (wxPoint *) 0 ;
4385 int result;
4386 PyObject * obj0 = 0 ;
4387 char *kwnames[] = {
4388 (char *) "self", NULL
4389 };
4390
4391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4393 if (SWIG_arg_fail(1)) SWIG_fail;
4394 result = (int) ((arg1)->y);
4395
4396 {
4397 resultobj = SWIG_From_int((int)(result));
4398 }
4399 return resultobj;
4400 fail:
4401 return NULL;
4402 }
4403
4404
4405 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4406 PyObject *resultobj;
4407 int arg1 = (int) 0 ;
4408 int arg2 = (int) 0 ;
4409 wxPoint *result;
4410 PyObject * obj0 = 0 ;
4411 PyObject * obj1 = 0 ;
4412 char *kwnames[] = {
4413 (char *) "x",(char *) "y", NULL
4414 };
4415
4416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4417 if (obj0) {
4418 {
4419 arg1 = (int)(SWIG_As_int(obj0));
4420 if (SWIG_arg_fail(1)) SWIG_fail;
4421 }
4422 }
4423 if (obj1) {
4424 {
4425 arg2 = (int)(SWIG_As_int(obj1));
4426 if (SWIG_arg_fail(2)) SWIG_fail;
4427 }
4428 }
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = (wxPoint *)new wxPoint(arg1,arg2);
4432
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4437 return resultobj;
4438 fail:
4439 return NULL;
4440 }
4441
4442
4443 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4444 PyObject *resultobj;
4445 wxPoint *arg1 = (wxPoint *) 0 ;
4446 PyObject * obj0 = 0 ;
4447 char *kwnames[] = {
4448 (char *) "self", NULL
4449 };
4450
4451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4453 if (SWIG_arg_fail(1)) SWIG_fail;
4454 {
4455 PyThreadState* __tstate = wxPyBeginAllowThreads();
4456 delete arg1;
4457
4458 wxPyEndAllowThreads(__tstate);
4459 if (PyErr_Occurred()) SWIG_fail;
4460 }
4461 Py_INCREF(Py_None); resultobj = Py_None;
4462 return resultobj;
4463 fail:
4464 return NULL;
4465 }
4466
4467
4468 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4469 PyObject *resultobj;
4470 wxPoint *arg1 = (wxPoint *) 0 ;
4471 wxPoint *arg2 = 0 ;
4472 bool result;
4473 wxPoint temp2 ;
4474 PyObject * obj0 = 0 ;
4475 PyObject * obj1 = 0 ;
4476 char *kwnames[] = {
4477 (char *) "self",(char *) "pt", NULL
4478 };
4479
4480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4482 if (SWIG_arg_fail(1)) SWIG_fail;
4483 {
4484 arg2 = &temp2;
4485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4486 }
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4490
4491 wxPyEndAllowThreads(__tstate);
4492 if (PyErr_Occurred()) SWIG_fail;
4493 }
4494 {
4495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4496 }
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj;
4505 wxPoint *arg1 = (wxPoint *) 0 ;
4506 wxPoint *arg2 = 0 ;
4507 bool result;
4508 wxPoint temp2 ;
4509 PyObject * obj0 = 0 ;
4510 PyObject * obj1 = 0 ;
4511 char *kwnames[] = {
4512 (char *) "self",(char *) "pt", NULL
4513 };
4514
4515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4517 if (SWIG_arg_fail(1)) SWIG_fail;
4518 {
4519 arg2 = &temp2;
4520 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4521 }
4522 {
4523 PyThreadState* __tstate = wxPyBeginAllowThreads();
4524 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4525
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 {
4530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4531 }
4532 return resultobj;
4533 fail:
4534 return NULL;
4535 }
4536
4537
4538 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4539 PyObject *resultobj;
4540 wxPoint *arg1 = (wxPoint *) 0 ;
4541 wxPoint *arg2 = 0 ;
4542 wxPoint result;
4543 wxPoint temp2 ;
4544 PyObject * obj0 = 0 ;
4545 PyObject * obj1 = 0 ;
4546 char *kwnames[] = {
4547 (char *) "self",(char *) "pt", NULL
4548 };
4549
4550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4552 if (SWIG_arg_fail(1)) SWIG_fail;
4553 {
4554 arg2 = &temp2;
4555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4556 }
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 result = (arg1)->operator +((wxPoint const &)*arg2);
4560
4561 wxPyEndAllowThreads(__tstate);
4562 if (PyErr_Occurred()) SWIG_fail;
4563 }
4564 {
4565 wxPoint * resultptr;
4566 resultptr = new wxPoint((wxPoint &)(result));
4567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4568 }
4569 return resultobj;
4570 fail:
4571 return NULL;
4572 }
4573
4574
4575 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4576 PyObject *resultobj;
4577 wxPoint *arg1 = (wxPoint *) 0 ;
4578 wxPoint *arg2 = 0 ;
4579 wxPoint result;
4580 wxPoint temp2 ;
4581 PyObject * obj0 = 0 ;
4582 PyObject * obj1 = 0 ;
4583 char *kwnames[] = {
4584 (char *) "self",(char *) "pt", NULL
4585 };
4586
4587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4589 if (SWIG_arg_fail(1)) SWIG_fail;
4590 {
4591 arg2 = &temp2;
4592 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4593 }
4594 {
4595 PyThreadState* __tstate = wxPyBeginAllowThreads();
4596 result = (arg1)->operator -((wxPoint const &)*arg2);
4597
4598 wxPyEndAllowThreads(__tstate);
4599 if (PyErr_Occurred()) SWIG_fail;
4600 }
4601 {
4602 wxPoint * resultptr;
4603 resultptr = new wxPoint((wxPoint &)(result));
4604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4605 }
4606 return resultobj;
4607 fail:
4608 return NULL;
4609 }
4610
4611
4612 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4613 PyObject *resultobj;
4614 wxPoint *arg1 = (wxPoint *) 0 ;
4615 wxPoint *arg2 = 0 ;
4616 wxPoint *result;
4617 wxPoint temp2 ;
4618 PyObject * obj0 = 0 ;
4619 PyObject * obj1 = 0 ;
4620 char *kwnames[] = {
4621 (char *) "self",(char *) "pt", NULL
4622 };
4623
4624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4626 if (SWIG_arg_fail(1)) SWIG_fail;
4627 {
4628 arg2 = &temp2;
4629 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4630 }
4631 {
4632 PyThreadState* __tstate = wxPyBeginAllowThreads();
4633 {
4634 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4635 result = (wxPoint *) &_result_ref;
4636 }
4637
4638 wxPyEndAllowThreads(__tstate);
4639 if (PyErr_Occurred()) SWIG_fail;
4640 }
4641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4642 return resultobj;
4643 fail:
4644 return NULL;
4645 }
4646
4647
4648 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4649 PyObject *resultobj;
4650 wxPoint *arg1 = (wxPoint *) 0 ;
4651 wxPoint *arg2 = 0 ;
4652 wxPoint *result;
4653 wxPoint temp2 ;
4654 PyObject * obj0 = 0 ;
4655 PyObject * obj1 = 0 ;
4656 char *kwnames[] = {
4657 (char *) "self",(char *) "pt", NULL
4658 };
4659
4660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4662 if (SWIG_arg_fail(1)) SWIG_fail;
4663 {
4664 arg2 = &temp2;
4665 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4666 }
4667 {
4668 PyThreadState* __tstate = wxPyBeginAllowThreads();
4669 {
4670 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4671 result = (wxPoint *) &_result_ref;
4672 }
4673
4674 wxPyEndAllowThreads(__tstate);
4675 if (PyErr_Occurred()) SWIG_fail;
4676 }
4677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4678 return resultobj;
4679 fail:
4680 return NULL;
4681 }
4682
4683
4684 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4685 PyObject *resultobj;
4686 wxPoint *arg1 = (wxPoint *) 0 ;
4687 long arg2 ;
4688 long arg3 ;
4689 PyObject * obj0 = 0 ;
4690 PyObject * obj1 = 0 ;
4691 PyObject * obj2 = 0 ;
4692 char *kwnames[] = {
4693 (char *) "self",(char *) "x",(char *) "y", NULL
4694 };
4695
4696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4698 if (SWIG_arg_fail(1)) SWIG_fail;
4699 {
4700 arg2 = (long)(SWIG_As_long(obj1));
4701 if (SWIG_arg_fail(2)) SWIG_fail;
4702 }
4703 {
4704 arg3 = (long)(SWIG_As_long(obj2));
4705 if (SWIG_arg_fail(3)) SWIG_fail;
4706 }
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 wxPoint_Set(arg1,arg2,arg3);
4710
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 Py_INCREF(Py_None); resultobj = Py_None;
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj;
4723 wxPoint *arg1 = (wxPoint *) 0 ;
4724 PyObject *result;
4725 PyObject * obj0 = 0 ;
4726 char *kwnames[] = {
4727 (char *) "self", NULL
4728 };
4729
4730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4732 if (SWIG_arg_fail(1)) SWIG_fail;
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (PyObject *)wxPoint_Get(arg1);
4736
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 resultobj = result;
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4748 PyObject *obj;
4749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4750 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4751 Py_INCREF(obj);
4752 return Py_BuildValue((char *)"");
4753 }
4754 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj;
4756 int arg1 = (int) 0 ;
4757 int arg2 = (int) 0 ;
4758 int arg3 = (int) 0 ;
4759 int arg4 = (int) 0 ;
4760 wxRect *result;
4761 PyObject * obj0 = 0 ;
4762 PyObject * obj1 = 0 ;
4763 PyObject * obj2 = 0 ;
4764 PyObject * obj3 = 0 ;
4765 char *kwnames[] = {
4766 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4767 };
4768
4769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4770 if (obj0) {
4771 {
4772 arg1 = (int)(SWIG_As_int(obj0));
4773 if (SWIG_arg_fail(1)) SWIG_fail;
4774 }
4775 }
4776 if (obj1) {
4777 {
4778 arg2 = (int)(SWIG_As_int(obj1));
4779 if (SWIG_arg_fail(2)) SWIG_fail;
4780 }
4781 }
4782 if (obj2) {
4783 {
4784 arg3 = (int)(SWIG_As_int(obj2));
4785 if (SWIG_arg_fail(3)) SWIG_fail;
4786 }
4787 }
4788 if (obj3) {
4789 {
4790 arg4 = (int)(SWIG_As_int(obj3));
4791 if (SWIG_arg_fail(4)) SWIG_fail;
4792 }
4793 }
4794 {
4795 PyThreadState* __tstate = wxPyBeginAllowThreads();
4796 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4797
4798 wxPyEndAllowThreads(__tstate);
4799 if (PyErr_Occurred()) SWIG_fail;
4800 }
4801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4802 return resultobj;
4803 fail:
4804 return NULL;
4805 }
4806
4807
4808 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4809 PyObject *resultobj;
4810 wxPoint *arg1 = 0 ;
4811 wxPoint *arg2 = 0 ;
4812 wxRect *result;
4813 wxPoint temp1 ;
4814 wxPoint temp2 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char *kwnames[] = {
4818 (char *) "topLeft",(char *) "bottomRight", NULL
4819 };
4820
4821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4822 {
4823 arg1 = &temp1;
4824 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4825 }
4826 {
4827 arg2 = &temp2;
4828 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4829 }
4830 {
4831 PyThreadState* __tstate = wxPyBeginAllowThreads();
4832 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4833
4834 wxPyEndAllowThreads(__tstate);
4835 if (PyErr_Occurred()) SWIG_fail;
4836 }
4837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4838 return resultobj;
4839 fail:
4840 return NULL;
4841 }
4842
4843
4844 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4845 PyObject *resultobj;
4846 wxPoint *arg1 = 0 ;
4847 wxSize *arg2 = 0 ;
4848 wxRect *result;
4849 wxPoint temp1 ;
4850 wxSize temp2 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 char *kwnames[] = {
4854 (char *) "pos",(char *) "size", NULL
4855 };
4856
4857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4858 {
4859 arg1 = &temp1;
4860 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4861 }
4862 {
4863 arg2 = &temp2;
4864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4865 }
4866 {
4867 PyThreadState* __tstate = wxPyBeginAllowThreads();
4868 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4869
4870 wxPyEndAllowThreads(__tstate);
4871 if (PyErr_Occurred()) SWIG_fail;
4872 }
4873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4874 return resultobj;
4875 fail:
4876 return NULL;
4877 }
4878
4879
4880 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4881 PyObject *resultobj;
4882 wxSize *arg1 = 0 ;
4883 wxRect *result;
4884 wxSize temp1 ;
4885 PyObject * obj0 = 0 ;
4886 char *kwnames[] = {
4887 (char *) "size", NULL
4888 };
4889
4890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4891 {
4892 arg1 = &temp1;
4893 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4894 }
4895 {
4896 PyThreadState* __tstate = wxPyBeginAllowThreads();
4897 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4898
4899 wxPyEndAllowThreads(__tstate);
4900 if (PyErr_Occurred()) SWIG_fail;
4901 }
4902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4910 PyObject *resultobj;
4911 wxRect *arg1 = (wxRect *) 0 ;
4912 PyObject * obj0 = 0 ;
4913 char *kwnames[] = {
4914 (char *) "self", NULL
4915 };
4916
4917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4919 if (SWIG_arg_fail(1)) SWIG_fail;
4920 {
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 delete arg1;
4923
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 Py_INCREF(Py_None); resultobj = Py_None;
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj;
4936 wxRect *arg1 = (wxRect *) 0 ;
4937 int result;
4938 PyObject * obj0 = 0 ;
4939 char *kwnames[] = {
4940 (char *) "self", NULL
4941 };
4942
4943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4945 if (SWIG_arg_fail(1)) SWIG_fail;
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = (int)((wxRect const *)arg1)->GetX();
4949
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 {
4954 resultobj = SWIG_From_int((int)(result));
4955 }
4956 return resultobj;
4957 fail:
4958 return NULL;
4959 }
4960
4961
4962 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4963 PyObject *resultobj;
4964 wxRect *arg1 = (wxRect *) 0 ;
4965 int arg2 ;
4966 PyObject * obj0 = 0 ;
4967 PyObject * obj1 = 0 ;
4968 char *kwnames[] = {
4969 (char *) "self",(char *) "x", NULL
4970 };
4971
4972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4974 if (SWIG_arg_fail(1)) SWIG_fail;
4975 {
4976 arg2 = (int)(SWIG_As_int(obj1));
4977 if (SWIG_arg_fail(2)) SWIG_fail;
4978 }
4979 {
4980 PyThreadState* __tstate = wxPyBeginAllowThreads();
4981 (arg1)->SetX(arg2);
4982
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 Py_INCREF(Py_None); resultobj = Py_None;
4987 return resultobj;
4988 fail:
4989 return NULL;
4990 }
4991
4992
4993 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4994 PyObject *resultobj;
4995 wxRect *arg1 = (wxRect *) 0 ;
4996 int result;
4997 PyObject * obj0 = 0 ;
4998 char *kwnames[] = {
4999 (char *) "self", NULL
5000 };
5001
5002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5004 if (SWIG_arg_fail(1)) SWIG_fail;
5005 {
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 result = (int)(arg1)->GetY();
5008
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 {
5013 resultobj = SWIG_From_int((int)(result));
5014 }
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5022 PyObject *resultobj;
5023 wxRect *arg1 = (wxRect *) 0 ;
5024 int arg2 ;
5025 PyObject * obj0 = 0 ;
5026 PyObject * obj1 = 0 ;
5027 char *kwnames[] = {
5028 (char *) "self",(char *) "y", NULL
5029 };
5030
5031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5033 if (SWIG_arg_fail(1)) SWIG_fail;
5034 {
5035 arg2 = (int)(SWIG_As_int(obj1));
5036 if (SWIG_arg_fail(2)) SWIG_fail;
5037 }
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 (arg1)->SetY(arg2);
5041
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 Py_INCREF(Py_None); resultobj = Py_None;
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5053 PyObject *resultobj;
5054 wxRect *arg1 = (wxRect *) 0 ;
5055 int result;
5056 PyObject * obj0 = 0 ;
5057 char *kwnames[] = {
5058 (char *) "self", NULL
5059 };
5060
5061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5063 if (SWIG_arg_fail(1)) SWIG_fail;
5064 {
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 result = (int)((wxRect const *)arg1)->GetWidth();
5067
5068 wxPyEndAllowThreads(__tstate);
5069 if (PyErr_Occurred()) SWIG_fail;
5070 }
5071 {
5072 resultobj = SWIG_From_int((int)(result));
5073 }
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj;
5082 wxRect *arg1 = (wxRect *) 0 ;
5083 int arg2 ;
5084 PyObject * obj0 = 0 ;
5085 PyObject * obj1 = 0 ;
5086 char *kwnames[] = {
5087 (char *) "self",(char *) "w", NULL
5088 };
5089
5090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5092 if (SWIG_arg_fail(1)) SWIG_fail;
5093 {
5094 arg2 = (int)(SWIG_As_int(obj1));
5095 if (SWIG_arg_fail(2)) SWIG_fail;
5096 }
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 (arg1)->SetWidth(arg2);
5100
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 Py_INCREF(Py_None); resultobj = Py_None;
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj;
5113 wxRect *arg1 = (wxRect *) 0 ;
5114 int result;
5115 PyObject * obj0 = 0 ;
5116 char *kwnames[] = {
5117 (char *) "self", NULL
5118 };
5119
5120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(1)) SWIG_fail;
5123 {
5124 PyThreadState* __tstate = wxPyBeginAllowThreads();
5125 result = (int)((wxRect const *)arg1)->GetHeight();
5126
5127 wxPyEndAllowThreads(__tstate);
5128 if (PyErr_Occurred()) SWIG_fail;
5129 }
5130 {
5131 resultobj = SWIG_From_int((int)(result));
5132 }
5133 return resultobj;
5134 fail:
5135 return NULL;
5136 }
5137
5138
5139 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5140 PyObject *resultobj;
5141 wxRect *arg1 = (wxRect *) 0 ;
5142 int arg2 ;
5143 PyObject * obj0 = 0 ;
5144 PyObject * obj1 = 0 ;
5145 char *kwnames[] = {
5146 (char *) "self",(char *) "h", NULL
5147 };
5148
5149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5151 if (SWIG_arg_fail(1)) SWIG_fail;
5152 {
5153 arg2 = (int)(SWIG_As_int(obj1));
5154 if (SWIG_arg_fail(2)) SWIG_fail;
5155 }
5156 {
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 (arg1)->SetHeight(arg2);
5159
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 Py_INCREF(Py_None); resultobj = Py_None;
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5171 PyObject *resultobj;
5172 wxRect *arg1 = (wxRect *) 0 ;
5173 wxPoint result;
5174 PyObject * obj0 = 0 ;
5175 char *kwnames[] = {
5176 (char *) "self", NULL
5177 };
5178
5179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(1)) SWIG_fail;
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 result = ((wxRect const *)arg1)->GetPosition();
5185
5186 wxPyEndAllowThreads(__tstate);
5187 if (PyErr_Occurred()) SWIG_fail;
5188 }
5189 {
5190 wxPoint * resultptr;
5191 resultptr = new wxPoint((wxPoint &)(result));
5192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5193 }
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj;
5202 wxRect *arg1 = (wxRect *) 0 ;
5203 wxPoint *arg2 = 0 ;
5204 wxPoint temp2 ;
5205 PyObject * obj0 = 0 ;
5206 PyObject * obj1 = 0 ;
5207 char *kwnames[] = {
5208 (char *) "self",(char *) "p", NULL
5209 };
5210
5211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5213 if (SWIG_arg_fail(1)) SWIG_fail;
5214 {
5215 arg2 = &temp2;
5216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5217 }
5218 {
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 (arg1)->SetPosition((wxPoint const &)*arg2);
5221
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 Py_INCREF(Py_None); resultobj = Py_None;
5226 return resultobj;
5227 fail:
5228 return NULL;
5229 }
5230
5231
5232 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5233 PyObject *resultobj;
5234 wxRect *arg1 = (wxRect *) 0 ;
5235 wxSize result;
5236 PyObject * obj0 = 0 ;
5237 char *kwnames[] = {
5238 (char *) "self", NULL
5239 };
5240
5241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5243 if (SWIG_arg_fail(1)) SWIG_fail;
5244 {
5245 PyThreadState* __tstate = wxPyBeginAllowThreads();
5246 result = ((wxRect const *)arg1)->GetSize();
5247
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 {
5252 wxSize * resultptr;
5253 resultptr = new wxSize((wxSize &)(result));
5254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5255 }
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj;
5264 wxRect *arg1 = (wxRect *) 0 ;
5265 wxSize *arg2 = 0 ;
5266 wxSize temp2 ;
5267 PyObject * obj0 = 0 ;
5268 PyObject * obj1 = 0 ;
5269 char *kwnames[] = {
5270 (char *) "self",(char *) "s", NULL
5271 };
5272
5273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5275 if (SWIG_arg_fail(1)) SWIG_fail;
5276 {
5277 arg2 = &temp2;
5278 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5279 }
5280 {
5281 PyThreadState* __tstate = wxPyBeginAllowThreads();
5282 (arg1)->SetSize((wxSize const &)*arg2);
5283
5284 wxPyEndAllowThreads(__tstate);
5285 if (PyErr_Occurred()) SWIG_fail;
5286 }
5287 Py_INCREF(Py_None); resultobj = Py_None;
5288 return resultobj;
5289 fail:
5290 return NULL;
5291 }
5292
5293
5294 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5295 PyObject *resultobj;
5296 wxRect *arg1 = (wxRect *) 0 ;
5297 wxPoint result;
5298 PyObject * obj0 = 0 ;
5299 char *kwnames[] = {
5300 (char *) "self", NULL
5301 };
5302
5303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5305 if (SWIG_arg_fail(1)) SWIG_fail;
5306 {
5307 PyThreadState* __tstate = wxPyBeginAllowThreads();
5308 result = ((wxRect const *)arg1)->GetTopLeft();
5309
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 {
5314 wxPoint * resultptr;
5315 resultptr = new wxPoint((wxPoint &)(result));
5316 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5317 }
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5325 PyObject *resultobj;
5326 wxRect *arg1 = (wxRect *) 0 ;
5327 wxPoint *arg2 = 0 ;
5328 wxPoint temp2 ;
5329 PyObject * obj0 = 0 ;
5330 PyObject * obj1 = 0 ;
5331 char *kwnames[] = {
5332 (char *) "self",(char *) "p", NULL
5333 };
5334
5335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5337 if (SWIG_arg_fail(1)) SWIG_fail;
5338 {
5339 arg2 = &temp2;
5340 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5341 }
5342 {
5343 PyThreadState* __tstate = wxPyBeginAllowThreads();
5344 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5345
5346 wxPyEndAllowThreads(__tstate);
5347 if (PyErr_Occurred()) SWIG_fail;
5348 }
5349 Py_INCREF(Py_None); resultobj = Py_None;
5350 return resultobj;
5351 fail:
5352 return NULL;
5353 }
5354
5355
5356 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5357 PyObject *resultobj;
5358 wxRect *arg1 = (wxRect *) 0 ;
5359 wxPoint result;
5360 PyObject * obj0 = 0 ;
5361 char *kwnames[] = {
5362 (char *) "self", NULL
5363 };
5364
5365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5367 if (SWIG_arg_fail(1)) SWIG_fail;
5368 {
5369 PyThreadState* __tstate = wxPyBeginAllowThreads();
5370 result = ((wxRect const *)arg1)->GetBottomRight();
5371
5372 wxPyEndAllowThreads(__tstate);
5373 if (PyErr_Occurred()) SWIG_fail;
5374 }
5375 {
5376 wxPoint * resultptr;
5377 resultptr = new wxPoint((wxPoint &)(result));
5378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5379 }
5380 return resultobj;
5381 fail:
5382 return NULL;
5383 }
5384
5385
5386 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5387 PyObject *resultobj;
5388 wxRect *arg1 = (wxRect *) 0 ;
5389 wxPoint *arg2 = 0 ;
5390 wxPoint temp2 ;
5391 PyObject * obj0 = 0 ;
5392 PyObject * obj1 = 0 ;
5393 char *kwnames[] = {
5394 (char *) "self",(char *) "p", NULL
5395 };
5396
5397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5399 if (SWIG_arg_fail(1)) SWIG_fail;
5400 {
5401 arg2 = &temp2;
5402 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5403 }
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5407
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 Py_INCREF(Py_None); resultobj = Py_None;
5412 return resultobj;
5413 fail:
5414 return NULL;
5415 }
5416
5417
5418 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5419 PyObject *resultobj;
5420 wxRect *arg1 = (wxRect *) 0 ;
5421 int result;
5422 PyObject * obj0 = 0 ;
5423 char *kwnames[] = {
5424 (char *) "self", NULL
5425 };
5426
5427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5429 if (SWIG_arg_fail(1)) SWIG_fail;
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 result = (int)((wxRect const *)arg1)->GetLeft();
5433
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 {
5438 resultobj = SWIG_From_int((int)(result));
5439 }
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj;
5448 wxRect *arg1 = (wxRect *) 0 ;
5449 int result;
5450 PyObject * obj0 = 0 ;
5451 char *kwnames[] = {
5452 (char *) "self", NULL
5453 };
5454
5455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5457 if (SWIG_arg_fail(1)) SWIG_fail;
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 result = (int)((wxRect const *)arg1)->GetTop();
5461
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 {
5466 resultobj = SWIG_From_int((int)(result));
5467 }
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5475 PyObject *resultobj;
5476 wxRect *arg1 = (wxRect *) 0 ;
5477 int result;
5478 PyObject * obj0 = 0 ;
5479 char *kwnames[] = {
5480 (char *) "self", NULL
5481 };
5482
5483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5485 if (SWIG_arg_fail(1)) SWIG_fail;
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = (int)((wxRect const *)arg1)->GetBottom();
5489
5490 wxPyEndAllowThreads(__tstate);
5491 if (PyErr_Occurred()) SWIG_fail;
5492 }
5493 {
5494 resultobj = SWIG_From_int((int)(result));
5495 }
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5503 PyObject *resultobj;
5504 wxRect *arg1 = (wxRect *) 0 ;
5505 int result;
5506 PyObject * obj0 = 0 ;
5507 char *kwnames[] = {
5508 (char *) "self", NULL
5509 };
5510
5511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5513 if (SWIG_arg_fail(1)) SWIG_fail;
5514 {
5515 PyThreadState* __tstate = wxPyBeginAllowThreads();
5516 result = (int)((wxRect const *)arg1)->GetRight();
5517
5518 wxPyEndAllowThreads(__tstate);
5519 if (PyErr_Occurred()) SWIG_fail;
5520 }
5521 {
5522 resultobj = SWIG_From_int((int)(result));
5523 }
5524 return resultobj;
5525 fail:
5526 return NULL;
5527 }
5528
5529
5530 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5531 PyObject *resultobj;
5532 wxRect *arg1 = (wxRect *) 0 ;
5533 int arg2 ;
5534 PyObject * obj0 = 0 ;
5535 PyObject * obj1 = 0 ;
5536 char *kwnames[] = {
5537 (char *) "self",(char *) "left", NULL
5538 };
5539
5540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5542 if (SWIG_arg_fail(1)) SWIG_fail;
5543 {
5544 arg2 = (int)(SWIG_As_int(obj1));
5545 if (SWIG_arg_fail(2)) SWIG_fail;
5546 }
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 (arg1)->SetLeft(arg2);
5550
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 Py_INCREF(Py_None); resultobj = Py_None;
5555 return resultobj;
5556 fail:
5557 return NULL;
5558 }
5559
5560
5561 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5562 PyObject *resultobj;
5563 wxRect *arg1 = (wxRect *) 0 ;
5564 int arg2 ;
5565 PyObject * obj0 = 0 ;
5566 PyObject * obj1 = 0 ;
5567 char *kwnames[] = {
5568 (char *) "self",(char *) "right", NULL
5569 };
5570
5571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5573 if (SWIG_arg_fail(1)) SWIG_fail;
5574 {
5575 arg2 = (int)(SWIG_As_int(obj1));
5576 if (SWIG_arg_fail(2)) SWIG_fail;
5577 }
5578 {
5579 PyThreadState* __tstate = wxPyBeginAllowThreads();
5580 (arg1)->SetRight(arg2);
5581
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 Py_INCREF(Py_None); resultobj = Py_None;
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5593 PyObject *resultobj;
5594 wxRect *arg1 = (wxRect *) 0 ;
5595 int arg2 ;
5596 PyObject * obj0 = 0 ;
5597 PyObject * obj1 = 0 ;
5598 char *kwnames[] = {
5599 (char *) "self",(char *) "top", NULL
5600 };
5601
5602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5604 if (SWIG_arg_fail(1)) SWIG_fail;
5605 {
5606 arg2 = (int)(SWIG_As_int(obj1));
5607 if (SWIG_arg_fail(2)) SWIG_fail;
5608 }
5609 {
5610 PyThreadState* __tstate = wxPyBeginAllowThreads();
5611 (arg1)->SetTop(arg2);
5612
5613 wxPyEndAllowThreads(__tstate);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 Py_INCREF(Py_None); resultobj = Py_None;
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj;
5625 wxRect *arg1 = (wxRect *) 0 ;
5626 int arg2 ;
5627 PyObject * obj0 = 0 ;
5628 PyObject * obj1 = 0 ;
5629 char *kwnames[] = {
5630 (char *) "self",(char *) "bottom", NULL
5631 };
5632
5633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5635 if (SWIG_arg_fail(1)) SWIG_fail;
5636 {
5637 arg2 = (int)(SWIG_As_int(obj1));
5638 if (SWIG_arg_fail(2)) SWIG_fail;
5639 }
5640 {
5641 PyThreadState* __tstate = wxPyBeginAllowThreads();
5642 (arg1)->SetBottom(arg2);
5643
5644 wxPyEndAllowThreads(__tstate);
5645 if (PyErr_Occurred()) SWIG_fail;
5646 }
5647 Py_INCREF(Py_None); resultobj = Py_None;
5648 return resultobj;
5649 fail:
5650 return NULL;
5651 }
5652
5653
5654 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5655 PyObject *resultobj;
5656 wxRect *arg1 = (wxRect *) 0 ;
5657 int arg2 ;
5658 int arg3 ;
5659 wxRect *result;
5660 PyObject * obj0 = 0 ;
5661 PyObject * obj1 = 0 ;
5662 PyObject * obj2 = 0 ;
5663 char *kwnames[] = {
5664 (char *) "self",(char *) "dx",(char *) "dy", NULL
5665 };
5666
5667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5669 if (SWIG_arg_fail(1)) SWIG_fail;
5670 {
5671 arg2 = (int)(SWIG_As_int(obj1));
5672 if (SWIG_arg_fail(2)) SWIG_fail;
5673 }
5674 {
5675 arg3 = (int)(SWIG_As_int(obj2));
5676 if (SWIG_arg_fail(3)) SWIG_fail;
5677 }
5678 {
5679 PyThreadState* __tstate = wxPyBeginAllowThreads();
5680 {
5681 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5682 result = (wxRect *) &_result_ref;
5683 }
5684
5685 wxPyEndAllowThreads(__tstate);
5686 if (PyErr_Occurred()) SWIG_fail;
5687 }
5688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5696 PyObject *resultobj;
5697 wxRect *arg1 = (wxRect *) 0 ;
5698 int arg2 ;
5699 int arg3 ;
5700 wxRect *result;
5701 PyObject * obj0 = 0 ;
5702 PyObject * obj1 = 0 ;
5703 PyObject * obj2 = 0 ;
5704 char *kwnames[] = {
5705 (char *) "self",(char *) "dx",(char *) "dy", NULL
5706 };
5707
5708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5710 if (SWIG_arg_fail(1)) SWIG_fail;
5711 {
5712 arg2 = (int)(SWIG_As_int(obj1));
5713 if (SWIG_arg_fail(2)) SWIG_fail;
5714 }
5715 {
5716 arg3 = (int)(SWIG_As_int(obj2));
5717 if (SWIG_arg_fail(3)) SWIG_fail;
5718 }
5719 {
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 {
5722 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5723 result = (wxRect *) &_result_ref;
5724 }
5725
5726 wxPyEndAllowThreads(__tstate);
5727 if (PyErr_Occurred()) SWIG_fail;
5728 }
5729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj;
5738 wxRect *arg1 = (wxRect *) 0 ;
5739 int arg2 ;
5740 int arg3 ;
5741 PyObject * obj0 = 0 ;
5742 PyObject * obj1 = 0 ;
5743 PyObject * obj2 = 0 ;
5744 char *kwnames[] = {
5745 (char *) "self",(char *) "dx",(char *) "dy", NULL
5746 };
5747
5748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5750 if (SWIG_arg_fail(1)) SWIG_fail;
5751 {
5752 arg2 = (int)(SWIG_As_int(obj1));
5753 if (SWIG_arg_fail(2)) SWIG_fail;
5754 }
5755 {
5756 arg3 = (int)(SWIG_As_int(obj2));
5757 if (SWIG_arg_fail(3)) SWIG_fail;
5758 }
5759 {
5760 PyThreadState* __tstate = wxPyBeginAllowThreads();
5761 (arg1)->Offset(arg2,arg3);
5762
5763 wxPyEndAllowThreads(__tstate);
5764 if (PyErr_Occurred()) SWIG_fail;
5765 }
5766 Py_INCREF(Py_None); resultobj = Py_None;
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5774 PyObject *resultobj;
5775 wxRect *arg1 = (wxRect *) 0 ;
5776 wxPoint *arg2 = 0 ;
5777 wxPoint temp2 ;
5778 PyObject * obj0 = 0 ;
5779 PyObject * obj1 = 0 ;
5780 char *kwnames[] = {
5781 (char *) "self",(char *) "pt", NULL
5782 };
5783
5784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5786 if (SWIG_arg_fail(1)) SWIG_fail;
5787 {
5788 arg2 = &temp2;
5789 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5790 }
5791 {
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 (arg1)->Offset((wxPoint const &)*arg2);
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxRect *arg1 = (wxRect *) 0 ;
5808 wxRect *arg2 = 0 ;
5809 wxRect result;
5810 wxRect temp2 ;
5811 PyObject * obj0 = 0 ;
5812 PyObject * obj1 = 0 ;
5813 char *kwnames[] = {
5814 (char *) "self",(char *) "rect", NULL
5815 };
5816
5817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5819 if (SWIG_arg_fail(1)) SWIG_fail;
5820 {
5821 arg2 = &temp2;
5822 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5823 }
5824 {
5825 PyThreadState* __tstate = wxPyBeginAllowThreads();
5826 result = (arg1)->Intersect((wxRect const &)*arg2);
5827
5828 wxPyEndAllowThreads(__tstate);
5829 if (PyErr_Occurred()) SWIG_fail;
5830 }
5831 {
5832 wxRect * resultptr;
5833 resultptr = new wxRect((wxRect &)(result));
5834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5835 }
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj;
5844 wxRect *arg1 = (wxRect *) 0 ;
5845 wxRect *arg2 = 0 ;
5846 wxRect result;
5847 wxRect temp2 ;
5848 PyObject * obj0 = 0 ;
5849 PyObject * obj1 = 0 ;
5850 char *kwnames[] = {
5851 (char *) "self",(char *) "rect", NULL
5852 };
5853
5854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 {
5858 arg2 = &temp2;
5859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5860 }
5861 {
5862 PyThreadState* __tstate = wxPyBeginAllowThreads();
5863 result = (arg1)->Union((wxRect const &)*arg2);
5864
5865 wxPyEndAllowThreads(__tstate);
5866 if (PyErr_Occurred()) SWIG_fail;
5867 }
5868 {
5869 wxRect * resultptr;
5870 resultptr = new wxRect((wxRect &)(result));
5871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5872 }
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5880 PyObject *resultobj;
5881 wxRect *arg1 = (wxRect *) 0 ;
5882 wxRect *arg2 = 0 ;
5883 wxRect result;
5884 wxRect temp2 ;
5885 PyObject * obj0 = 0 ;
5886 PyObject * obj1 = 0 ;
5887 char *kwnames[] = {
5888 (char *) "self",(char *) "rect", NULL
5889 };
5890
5891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5893 if (SWIG_arg_fail(1)) SWIG_fail;
5894 {
5895 arg2 = &temp2;
5896 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5897 }
5898 {
5899 PyThreadState* __tstate = wxPyBeginAllowThreads();
5900 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5901
5902 wxPyEndAllowThreads(__tstate);
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 {
5906 wxRect * resultptr;
5907 resultptr = new wxRect((wxRect &)(result));
5908 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5909 }
5910 return resultobj;
5911 fail:
5912 return NULL;
5913 }
5914
5915
5916 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj;
5918 wxRect *arg1 = (wxRect *) 0 ;
5919 wxRect *arg2 = 0 ;
5920 wxRect *result;
5921 wxRect temp2 ;
5922 PyObject * obj0 = 0 ;
5923 PyObject * obj1 = 0 ;
5924 char *kwnames[] = {
5925 (char *) "self",(char *) "rect", NULL
5926 };
5927
5928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5930 if (SWIG_arg_fail(1)) SWIG_fail;
5931 {
5932 arg2 = &temp2;
5933 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5934 }
5935 {
5936 PyThreadState* __tstate = wxPyBeginAllowThreads();
5937 {
5938 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5939 result = (wxRect *) &_result_ref;
5940 }
5941
5942 wxPyEndAllowThreads(__tstate);
5943 if (PyErr_Occurred()) SWIG_fail;
5944 }
5945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5946 return resultobj;
5947 fail:
5948 return NULL;
5949 }
5950
5951
5952 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj;
5954 wxRect *arg1 = (wxRect *) 0 ;
5955 wxRect *arg2 = 0 ;
5956 bool result;
5957 wxRect temp2 ;
5958 PyObject * obj0 = 0 ;
5959 PyObject * obj1 = 0 ;
5960 char *kwnames[] = {
5961 (char *) "self",(char *) "rect", NULL
5962 };
5963
5964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5966 if (SWIG_arg_fail(1)) SWIG_fail;
5967 {
5968 arg2 = &temp2;
5969 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5970 }
5971 {
5972 PyThreadState* __tstate = wxPyBeginAllowThreads();
5973 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5974
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 {
5979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5980 }
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5988 PyObject *resultobj;
5989 wxRect *arg1 = (wxRect *) 0 ;
5990 wxRect *arg2 = 0 ;
5991 bool result;
5992 wxRect temp2 ;
5993 PyObject * obj0 = 0 ;
5994 PyObject * obj1 = 0 ;
5995 char *kwnames[] = {
5996 (char *) "self",(char *) "rect", NULL
5997 };
5998
5999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6001 if (SWIG_arg_fail(1)) SWIG_fail;
6002 {
6003 arg2 = &temp2;
6004 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6005 }
6006 {
6007 PyThreadState* __tstate = wxPyBeginAllowThreads();
6008 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6009
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 {
6014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6015 }
6016 return resultobj;
6017 fail:
6018 return NULL;
6019 }
6020
6021
6022 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6023 PyObject *resultobj;
6024 wxRect *arg1 = (wxRect *) 0 ;
6025 int arg2 ;
6026 int arg3 ;
6027 bool result;
6028 PyObject * obj0 = 0 ;
6029 PyObject * obj1 = 0 ;
6030 PyObject * obj2 = 0 ;
6031 char *kwnames[] = {
6032 (char *) "self",(char *) "x",(char *) "y", NULL
6033 };
6034
6035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6037 if (SWIG_arg_fail(1)) SWIG_fail;
6038 {
6039 arg2 = (int)(SWIG_As_int(obj1));
6040 if (SWIG_arg_fail(2)) SWIG_fail;
6041 }
6042 {
6043 arg3 = (int)(SWIG_As_int(obj2));
6044 if (SWIG_arg_fail(3)) SWIG_fail;
6045 }
6046 {
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6049
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 {
6054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6055 }
6056 return resultobj;
6057 fail:
6058 return NULL;
6059 }
6060
6061
6062 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj;
6064 wxRect *arg1 = (wxRect *) 0 ;
6065 wxPoint *arg2 = 0 ;
6066 bool result;
6067 wxPoint temp2 ;
6068 PyObject * obj0 = 0 ;
6069 PyObject * obj1 = 0 ;
6070 char *kwnames[] = {
6071 (char *) "self",(char *) "pt", NULL
6072 };
6073
6074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6076 if (SWIG_arg_fail(1)) SWIG_fail;
6077 {
6078 arg2 = &temp2;
6079 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6080 }
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6084
6085 wxPyEndAllowThreads(__tstate);
6086 if (PyErr_Occurred()) SWIG_fail;
6087 }
6088 {
6089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6090 }
6091 return resultobj;
6092 fail:
6093 return NULL;
6094 }
6095
6096
6097 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6098 PyObject *resultobj;
6099 wxRect *arg1 = (wxRect *) 0 ;
6100 wxRect *arg2 = 0 ;
6101 bool result;
6102 wxRect temp2 ;
6103 PyObject * obj0 = 0 ;
6104 PyObject * obj1 = 0 ;
6105 char *kwnames[] = {
6106 (char *) "self",(char *) "rect", NULL
6107 };
6108
6109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6111 if (SWIG_arg_fail(1)) SWIG_fail;
6112 {
6113 arg2 = &temp2;
6114 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6115 }
6116 {
6117 PyThreadState* __tstate = wxPyBeginAllowThreads();
6118 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6119
6120 wxPyEndAllowThreads(__tstate);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 {
6124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6125 }
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj;
6134 wxRect *arg1 = (wxRect *) 0 ;
6135 int arg2 ;
6136 PyObject * obj0 = 0 ;
6137 PyObject * obj1 = 0 ;
6138 char *kwnames[] = {
6139 (char *) "self",(char *) "x", NULL
6140 };
6141
6142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6144 if (SWIG_arg_fail(1)) SWIG_fail;
6145 {
6146 arg2 = (int)(SWIG_As_int(obj1));
6147 if (SWIG_arg_fail(2)) SWIG_fail;
6148 }
6149 if (arg1) (arg1)->x = arg2;
6150
6151 Py_INCREF(Py_None); resultobj = Py_None;
6152 return resultobj;
6153 fail:
6154 return NULL;
6155 }
6156
6157
6158 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6159 PyObject *resultobj;
6160 wxRect *arg1 = (wxRect *) 0 ;
6161 int result;
6162 PyObject * obj0 = 0 ;
6163 char *kwnames[] = {
6164 (char *) "self", NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6169 if (SWIG_arg_fail(1)) SWIG_fail;
6170 result = (int) ((arg1)->x);
6171
6172 {
6173 resultobj = SWIG_From_int((int)(result));
6174 }
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxRect *arg1 = (wxRect *) 0 ;
6184 int arg2 ;
6185 PyObject * obj0 = 0 ;
6186 PyObject * obj1 = 0 ;
6187 char *kwnames[] = {
6188 (char *) "self",(char *) "y", NULL
6189 };
6190
6191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6193 if (SWIG_arg_fail(1)) SWIG_fail;
6194 {
6195 arg2 = (int)(SWIG_As_int(obj1));
6196 if (SWIG_arg_fail(2)) SWIG_fail;
6197 }
6198 if (arg1) (arg1)->y = arg2;
6199
6200 Py_INCREF(Py_None); resultobj = Py_None;
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj;
6209 wxRect *arg1 = (wxRect *) 0 ;
6210 int result;
6211 PyObject * obj0 = 0 ;
6212 char *kwnames[] = {
6213 (char *) "self", NULL
6214 };
6215
6216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6218 if (SWIG_arg_fail(1)) SWIG_fail;
6219 result = (int) ((arg1)->y);
6220
6221 {
6222 resultobj = SWIG_From_int((int)(result));
6223 }
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 int arg2 ;
6234 PyObject * obj0 = 0 ;
6235 PyObject * obj1 = 0 ;
6236 char *kwnames[] = {
6237 (char *) "self",(char *) "width", NULL
6238 };
6239
6240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6242 if (SWIG_arg_fail(1)) SWIG_fail;
6243 {
6244 arg2 = (int)(SWIG_As_int(obj1));
6245 if (SWIG_arg_fail(2)) SWIG_fail;
6246 }
6247 if (arg1) (arg1)->width = arg2;
6248
6249 Py_INCREF(Py_None); resultobj = Py_None;
6250 return resultobj;
6251 fail:
6252 return NULL;
6253 }
6254
6255
6256 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6257 PyObject *resultobj;
6258 wxRect *arg1 = (wxRect *) 0 ;
6259 int result;
6260 PyObject * obj0 = 0 ;
6261 char *kwnames[] = {
6262 (char *) "self", NULL
6263 };
6264
6265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6267 if (SWIG_arg_fail(1)) SWIG_fail;
6268 result = (int) ((arg1)->width);
6269
6270 {
6271 resultobj = SWIG_From_int((int)(result));
6272 }
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj;
6281 wxRect *arg1 = (wxRect *) 0 ;
6282 int arg2 ;
6283 PyObject * obj0 = 0 ;
6284 PyObject * obj1 = 0 ;
6285 char *kwnames[] = {
6286 (char *) "self",(char *) "height", NULL
6287 };
6288
6289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6291 if (SWIG_arg_fail(1)) SWIG_fail;
6292 {
6293 arg2 = (int)(SWIG_As_int(obj1));
6294 if (SWIG_arg_fail(2)) SWIG_fail;
6295 }
6296 if (arg1) (arg1)->height = arg2;
6297
6298 Py_INCREF(Py_None); resultobj = Py_None;
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6306 PyObject *resultobj;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int result;
6309 PyObject * obj0 = 0 ;
6310 char *kwnames[] = {
6311 (char *) "self", NULL
6312 };
6313
6314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6316 if (SWIG_arg_fail(1)) SWIG_fail;
6317 result = (int) ((arg1)->height);
6318
6319 {
6320 resultobj = SWIG_From_int((int)(result));
6321 }
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6329 PyObject *resultobj;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 int arg2 = (int) 0 ;
6332 int arg3 = (int) 0 ;
6333 int arg4 = (int) 0 ;
6334 int arg5 = (int) 0 ;
6335 PyObject * obj0 = 0 ;
6336 PyObject * obj1 = 0 ;
6337 PyObject * obj2 = 0 ;
6338 PyObject * obj3 = 0 ;
6339 PyObject * obj4 = 0 ;
6340 char *kwnames[] = {
6341 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6342 };
6343
6344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6346 if (SWIG_arg_fail(1)) SWIG_fail;
6347 if (obj1) {
6348 {
6349 arg2 = (int)(SWIG_As_int(obj1));
6350 if (SWIG_arg_fail(2)) SWIG_fail;
6351 }
6352 }
6353 if (obj2) {
6354 {
6355 arg3 = (int)(SWIG_As_int(obj2));
6356 if (SWIG_arg_fail(3)) SWIG_fail;
6357 }
6358 }
6359 if (obj3) {
6360 {
6361 arg4 = (int)(SWIG_As_int(obj3));
6362 if (SWIG_arg_fail(4)) SWIG_fail;
6363 }
6364 }
6365 if (obj4) {
6366 {
6367 arg5 = (int)(SWIG_As_int(obj4));
6368 if (SWIG_arg_fail(5)) SWIG_fail;
6369 }
6370 }
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 Py_INCREF(Py_None); resultobj = Py_None;
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6386 PyObject *resultobj;
6387 wxRect *arg1 = (wxRect *) 0 ;
6388 PyObject *result;
6389 PyObject * obj0 = 0 ;
6390 char *kwnames[] = {
6391 (char *) "self", NULL
6392 };
6393
6394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6396 if (SWIG_arg_fail(1)) SWIG_fail;
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 result = (PyObject *)wxRect_Get(arg1);
6400
6401 wxPyEndAllowThreads(__tstate);
6402 if (PyErr_Occurred()) SWIG_fail;
6403 }
6404 resultobj = result;
6405 return resultobj;
6406 fail:
6407 return NULL;
6408 }
6409
6410
6411 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6412 PyObject *obj;
6413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6414 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6415 Py_INCREF(obj);
6416 return Py_BuildValue((char *)"");
6417 }
6418 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6419 PyObject *resultobj;
6420 wxRect *arg1 = (wxRect *) 0 ;
6421 wxRect *arg2 = (wxRect *) 0 ;
6422 PyObject *result;
6423 PyObject * obj0 = 0 ;
6424 PyObject * obj1 = 0 ;
6425 char *kwnames[] = {
6426 (char *) "r1",(char *) "r2", NULL
6427 };
6428
6429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6431 if (SWIG_arg_fail(1)) SWIG_fail;
6432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6433 if (SWIG_arg_fail(2)) SWIG_fail;
6434 {
6435 if (!wxPyCheckForApp()) SWIG_fail;
6436 PyThreadState* __tstate = wxPyBeginAllowThreads();
6437 result = (PyObject *)wxIntersectRect(arg1,arg2);
6438
6439 wxPyEndAllowThreads(__tstate);
6440 if (PyErr_Occurred()) SWIG_fail;
6441 }
6442 resultobj = result;
6443 return resultobj;
6444 fail:
6445 return NULL;
6446 }
6447
6448
6449 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6450 PyObject *resultobj;
6451 double arg1 = (double) 0.0 ;
6452 double arg2 = (double) 0.0 ;
6453 wxPoint2D *result;
6454 PyObject * obj0 = 0 ;
6455 PyObject * obj1 = 0 ;
6456 char *kwnames[] = {
6457 (char *) "x",(char *) "y", NULL
6458 };
6459
6460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6461 if (obj0) {
6462 {
6463 arg1 = (double)(SWIG_As_double(obj0));
6464 if (SWIG_arg_fail(1)) SWIG_fail;
6465 }
6466 }
6467 if (obj1) {
6468 {
6469 arg2 = (double)(SWIG_As_double(obj1));
6470 if (SWIG_arg_fail(2)) SWIG_fail;
6471 }
6472 }
6473 {
6474 PyThreadState* __tstate = wxPyBeginAllowThreads();
6475 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6476
6477 wxPyEndAllowThreads(__tstate);
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj;
6489 wxPoint2D *arg1 = 0 ;
6490 wxPoint2D *result;
6491 wxPoint2D temp1 ;
6492 PyObject * obj0 = 0 ;
6493 char *kwnames[] = {
6494 (char *) "pt", NULL
6495 };
6496
6497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6498 {
6499 arg1 = &temp1;
6500 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6501 }
6502 {
6503 PyThreadState* __tstate = wxPyBeginAllowThreads();
6504 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6505
6506 wxPyEndAllowThreads(__tstate);
6507 if (PyErr_Occurred()) SWIG_fail;
6508 }
6509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6510 return resultobj;
6511 fail:
6512 return NULL;
6513 }
6514
6515
6516 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6517 PyObject *resultobj;
6518 wxPoint *arg1 = 0 ;
6519 wxPoint2D *result;
6520 wxPoint temp1 ;
6521 PyObject * obj0 = 0 ;
6522 char *kwnames[] = {
6523 (char *) "pt", NULL
6524 };
6525
6526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6527 {
6528 arg1 = &temp1;
6529 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6530 }
6531 {
6532 PyThreadState* __tstate = wxPyBeginAllowThreads();
6533 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6534
6535 wxPyEndAllowThreads(__tstate);
6536 if (PyErr_Occurred()) SWIG_fail;
6537 }
6538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6548 int *arg2 = (int *) 0 ;
6549 int *arg3 = (int *) 0 ;
6550 int temp2 ;
6551 int res2 = 0 ;
6552 int temp3 ;
6553 int res3 = 0 ;
6554 PyObject * obj0 = 0 ;
6555 char *kwnames[] = {
6556 (char *) "self", NULL
6557 };
6558
6559 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6560 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6563 if (SWIG_arg_fail(1)) SWIG_fail;
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6567
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 Py_INCREF(Py_None); resultobj = Py_None;
6572 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6573 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6574 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6575 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6576 return resultobj;
6577 fail:
6578 return NULL;
6579 }
6580
6581
6582 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6583 PyObject *resultobj;
6584 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6585 int *arg2 = (int *) 0 ;
6586 int *arg3 = (int *) 0 ;
6587 int temp2 ;
6588 int res2 = 0 ;
6589 int temp3 ;
6590 int res3 = 0 ;
6591 PyObject * obj0 = 0 ;
6592 char *kwnames[] = {
6593 (char *) "self", NULL
6594 };
6595
6596 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6597 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6600 if (SWIG_arg_fail(1)) SWIG_fail;
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6604
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 Py_INCREF(Py_None); resultobj = Py_None;
6609 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6610 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6611 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6612 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj;
6621 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6622 double result;
6623 PyObject * obj0 = 0 ;
6624 char *kwnames[] = {
6625 (char *) "self", NULL
6626 };
6627
6628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6630 if (SWIG_arg_fail(1)) SWIG_fail;
6631 {
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6634
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 {
6639 resultobj = SWIG_From_double((double)(result));
6640 }
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj;
6649 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6650 double result;
6651 PyObject * obj0 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self", NULL
6654 };
6655
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 {
6667 resultobj = SWIG_From_double((double)(result));
6668 }
6669 return resultobj;
6670 fail:
6671 return NULL;
6672 }
6673
6674
6675 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6676 PyObject *resultobj;
6677 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6678 double arg2 ;
6679 PyObject * obj0 = 0 ;
6680 PyObject * obj1 = 0 ;
6681 char *kwnames[] = {
6682 (char *) "self",(char *) "length", NULL
6683 };
6684
6685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6687 if (SWIG_arg_fail(1)) SWIG_fail;
6688 {
6689 arg2 = (double)(SWIG_As_double(obj1));
6690 if (SWIG_arg_fail(2)) SWIG_fail;
6691 }
6692 {
6693 PyThreadState* __tstate = wxPyBeginAllowThreads();
6694 (arg1)->SetVectorLength(arg2);
6695
6696 wxPyEndAllowThreads(__tstate);
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 Py_INCREF(Py_None); resultobj = Py_None;
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6707 PyObject *resultobj;
6708 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6709 double arg2 ;
6710 PyObject * obj0 = 0 ;
6711 PyObject * obj1 = 0 ;
6712 char *kwnames[] = {
6713 (char *) "self",(char *) "degrees", NULL
6714 };
6715
6716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6718 if (SWIG_arg_fail(1)) SWIG_fail;
6719 {
6720 arg2 = (double)(SWIG_As_double(obj1));
6721 if (SWIG_arg_fail(2)) SWIG_fail;
6722 }
6723 {
6724 PyThreadState* __tstate = wxPyBeginAllowThreads();
6725 (arg1)->SetVectorAngle(arg2);
6726
6727 wxPyEndAllowThreads(__tstate);
6728 if (PyErr_Occurred()) SWIG_fail;
6729 }
6730 Py_INCREF(Py_None); resultobj = Py_None;
6731 return resultobj;
6732 fail:
6733 return NULL;
6734 }
6735
6736
6737 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6738 PyObject *resultobj;
6739 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6740 wxPoint2D *arg2 = 0 ;
6741 double result;
6742 wxPoint2D temp2 ;
6743 PyObject * obj0 = 0 ;
6744 PyObject * obj1 = 0 ;
6745 char *kwnames[] = {
6746 (char *) "self",(char *) "pt", NULL
6747 };
6748
6749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6751 if (SWIG_arg_fail(1)) SWIG_fail;
6752 {
6753 arg2 = &temp2;
6754 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6755 }
6756 {
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6759
6760 wxPyEndAllowThreads(__tstate);
6761 if (PyErr_Occurred()) SWIG_fail;
6762 }
6763 {
6764 resultobj = SWIG_From_double((double)(result));
6765 }
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj;
6774 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6775 wxPoint2D *arg2 = 0 ;
6776 double result;
6777 wxPoint2D temp2 ;
6778 PyObject * obj0 = 0 ;
6779 PyObject * obj1 = 0 ;
6780 char *kwnames[] = {
6781 (char *) "self",(char *) "pt", NULL
6782 };
6783
6784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6786 if (SWIG_arg_fail(1)) SWIG_fail;
6787 {
6788 arg2 = &temp2;
6789 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6790 }
6791 {
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6794
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 {
6799 resultobj = SWIG_From_double((double)(result));
6800 }
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6808 PyObject *resultobj;
6809 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6810 wxPoint2D *arg2 = 0 ;
6811 double result;
6812 wxPoint2D temp2 ;
6813 PyObject * obj0 = 0 ;
6814 PyObject * obj1 = 0 ;
6815 char *kwnames[] = {
6816 (char *) "self",(char *) "vec", NULL
6817 };
6818
6819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6821 if (SWIG_arg_fail(1)) SWIG_fail;
6822 {
6823 arg2 = &temp2;
6824 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6825 }
6826 {
6827 PyThreadState* __tstate = wxPyBeginAllowThreads();
6828 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6829
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 {
6834 resultobj = SWIG_From_double((double)(result));
6835 }
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6843 PyObject *resultobj;
6844 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6845 wxPoint2D *arg2 = 0 ;
6846 double result;
6847 wxPoint2D temp2 ;
6848 PyObject * obj0 = 0 ;
6849 PyObject * obj1 = 0 ;
6850 char *kwnames[] = {
6851 (char *) "self",(char *) "vec", NULL
6852 };
6853
6854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6856 if (SWIG_arg_fail(1)) SWIG_fail;
6857 {
6858 arg2 = &temp2;
6859 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6860 }
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 {
6869 resultobj = SWIG_From_double((double)(result));
6870 }
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj;
6879 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6880 wxPoint2D result;
6881 PyObject * obj0 = 0 ;
6882 char *kwnames[] = {
6883 (char *) "self", NULL
6884 };
6885
6886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6888 if (SWIG_arg_fail(1)) SWIG_fail;
6889 {
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 result = (arg1)->operator -();
6892
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 {
6897 wxPoint2D * resultptr;
6898 resultptr = new wxPoint2D((wxPoint2D &)(result));
6899 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6900 }
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6908 PyObject *resultobj;
6909 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6910 wxPoint2D *arg2 = 0 ;
6911 wxPoint2D *result;
6912 wxPoint2D temp2 ;
6913 PyObject * obj0 = 0 ;
6914 PyObject * obj1 = 0 ;
6915 char *kwnames[] = {
6916 (char *) "self",(char *) "pt", NULL
6917 };
6918
6919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6921 if (SWIG_arg_fail(1)) SWIG_fail;
6922 {
6923 arg2 = &temp2;
6924 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6925 }
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 {
6929 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6930 result = (wxPoint2D *) &_result_ref;
6931 }
6932
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj;
6945 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6946 wxPoint2D *arg2 = 0 ;
6947 wxPoint2D *result;
6948 wxPoint2D temp2 ;
6949 PyObject * obj0 = 0 ;
6950 PyObject * obj1 = 0 ;
6951 char *kwnames[] = {
6952 (char *) "self",(char *) "pt", NULL
6953 };
6954
6955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6957 if (SWIG_arg_fail(1)) SWIG_fail;
6958 {
6959 arg2 = &temp2;
6960 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6961 }
6962 {
6963 PyThreadState* __tstate = wxPyBeginAllowThreads();
6964 {
6965 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6966 result = (wxPoint2D *) &_result_ref;
6967 }
6968
6969 wxPyEndAllowThreads(__tstate);
6970 if (PyErr_Occurred()) SWIG_fail;
6971 }
6972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6973 return resultobj;
6974 fail:
6975 return NULL;
6976 }
6977
6978
6979 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6980 PyObject *resultobj;
6981 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6982 wxPoint2D *arg2 = 0 ;
6983 wxPoint2D *result;
6984 wxPoint2D temp2 ;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 char *kwnames[] = {
6988 (char *) "self",(char *) "pt", NULL
6989 };
6990
6991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6993 if (SWIG_arg_fail(1)) SWIG_fail;
6994 {
6995 arg2 = &temp2;
6996 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6997 }
6998 {
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 {
7001 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7002 result = (wxPoint2D *) &_result_ref;
7003 }
7004
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj;
7017 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7018 wxPoint2D *arg2 = 0 ;
7019 wxPoint2D *result;
7020 wxPoint2D temp2 ;
7021 PyObject * obj0 = 0 ;
7022 PyObject * obj1 = 0 ;
7023 char *kwnames[] = {
7024 (char *) "self",(char *) "pt", NULL
7025 };
7026
7027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7029 if (SWIG_arg_fail(1)) SWIG_fail;
7030 {
7031 arg2 = &temp2;
7032 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7033 }
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 {
7037 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7038 result = (wxPoint2D *) &_result_ref;
7039 }
7040
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7052 PyObject *resultobj;
7053 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7054 wxPoint2D *arg2 = 0 ;
7055 bool result;
7056 wxPoint2D temp2 ;
7057 PyObject * obj0 = 0 ;
7058 PyObject * obj1 = 0 ;
7059 char *kwnames[] = {
7060 (char *) "self",(char *) "pt", NULL
7061 };
7062
7063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7065 if (SWIG_arg_fail(1)) SWIG_fail;
7066 {
7067 arg2 = &temp2;
7068 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7069 }
7070 {
7071 PyThreadState* __tstate = wxPyBeginAllowThreads();
7072 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7073
7074 wxPyEndAllowThreads(__tstate);
7075 if (PyErr_Occurred()) SWIG_fail;
7076 }
7077 {
7078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7079 }
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7087 PyObject *resultobj;
7088 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7089 wxPoint2D *arg2 = 0 ;
7090 bool result;
7091 wxPoint2D temp2 ;
7092 PyObject * obj0 = 0 ;
7093 PyObject * obj1 = 0 ;
7094 char *kwnames[] = {
7095 (char *) "self",(char *) "pt", NULL
7096 };
7097
7098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7100 if (SWIG_arg_fail(1)) SWIG_fail;
7101 {
7102 arg2 = &temp2;
7103 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7104 }
7105 {
7106 PyThreadState* __tstate = wxPyBeginAllowThreads();
7107 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7108
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 {
7113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7114 }
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7124 double arg2 ;
7125 PyObject * obj0 = 0 ;
7126 PyObject * obj1 = 0 ;
7127 char *kwnames[] = {
7128 (char *) "self",(char *) "m_x", NULL
7129 };
7130
7131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7133 if (SWIG_arg_fail(1)) SWIG_fail;
7134 {
7135 arg2 = (double)(SWIG_As_double(obj1));
7136 if (SWIG_arg_fail(2)) SWIG_fail;
7137 }
7138 if (arg1) (arg1)->m_x = arg2;
7139
7140 Py_INCREF(Py_None); resultobj = Py_None;
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj;
7149 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7150 double result;
7151 PyObject * obj0 = 0 ;
7152 char *kwnames[] = {
7153 (char *) "self", NULL
7154 };
7155
7156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7158 if (SWIG_arg_fail(1)) SWIG_fail;
7159 result = (double) ((arg1)->m_x);
7160
7161 {
7162 resultobj = SWIG_From_double((double)(result));
7163 }
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj;
7172 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7173 double arg2 ;
7174 PyObject * obj0 = 0 ;
7175 PyObject * obj1 = 0 ;
7176 char *kwnames[] = {
7177 (char *) "self",(char *) "m_y", NULL
7178 };
7179
7180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7182 if (SWIG_arg_fail(1)) SWIG_fail;
7183 {
7184 arg2 = (double)(SWIG_As_double(obj1));
7185 if (SWIG_arg_fail(2)) SWIG_fail;
7186 }
7187 if (arg1) (arg1)->m_y = arg2;
7188
7189 Py_INCREF(Py_None); resultobj = Py_None;
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj;
7198 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7199 double result;
7200 PyObject * obj0 = 0 ;
7201 char *kwnames[] = {
7202 (char *) "self", NULL
7203 };
7204
7205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7207 if (SWIG_arg_fail(1)) SWIG_fail;
7208 result = (double) ((arg1)->m_y);
7209
7210 {
7211 resultobj = SWIG_From_double((double)(result));
7212 }
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj;
7221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7222 double arg2 = (double) 0 ;
7223 double arg3 = (double) 0 ;
7224 PyObject * obj0 = 0 ;
7225 PyObject * obj1 = 0 ;
7226 PyObject * obj2 = 0 ;
7227 char *kwnames[] = {
7228 (char *) "self",(char *) "x",(char *) "y", NULL
7229 };
7230
7231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7233 if (SWIG_arg_fail(1)) SWIG_fail;
7234 if (obj1) {
7235 {
7236 arg2 = (double)(SWIG_As_double(obj1));
7237 if (SWIG_arg_fail(2)) SWIG_fail;
7238 }
7239 }
7240 if (obj2) {
7241 {
7242 arg3 = (double)(SWIG_As_double(obj2));
7243 if (SWIG_arg_fail(3)) SWIG_fail;
7244 }
7245 }
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 wxPoint2D_Set(arg1,arg2,arg3);
7249
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 Py_INCREF(Py_None); resultobj = Py_None;
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj;
7262 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7263 PyObject *result;
7264 PyObject * obj0 = 0 ;
7265 char *kwnames[] = {
7266 (char *) "self", NULL
7267 };
7268
7269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7271 if (SWIG_arg_fail(1)) SWIG_fail;
7272 {
7273 PyThreadState* __tstate = wxPyBeginAllowThreads();
7274 result = (PyObject *)wxPoint2D_Get(arg1);
7275
7276 wxPyEndAllowThreads(__tstate);
7277 if (PyErr_Occurred()) SWIG_fail;
7278 }
7279 resultobj = result;
7280 return resultobj;
7281 fail:
7282 return NULL;
7283 }
7284
7285
7286 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7287 PyObject *obj;
7288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7289 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7290 Py_INCREF(obj);
7291 return Py_BuildValue((char *)"");
7292 }
7293 static int _wrap_DefaultPosition_set(PyObject *) {
7294 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7295 return 1;
7296 }
7297
7298
7299 static PyObject *_wrap_DefaultPosition_get(void) {
7300 PyObject *pyobj;
7301
7302 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7303 return pyobj;
7304 }
7305
7306
7307 static int _wrap_DefaultSize_set(PyObject *) {
7308 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7309 return 1;
7310 }
7311
7312
7313 static PyObject *_wrap_DefaultSize_get(void) {
7314 PyObject *pyobj;
7315
7316 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7317 return pyobj;
7318 }
7319
7320
7321 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7322 PyObject *resultobj;
7323 PyObject *arg1 = (PyObject *) 0 ;
7324 wxPyInputStream *result;
7325 PyObject * obj0 = 0 ;
7326 char *kwnames[] = {
7327 (char *) "p", NULL
7328 };
7329
7330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7331 arg1 = obj0;
7332 {
7333 PyThreadState* __tstate = wxPyBeginAllowThreads();
7334 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7335
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7347 PyObject *resultobj;
7348 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7349 PyObject * obj0 = 0 ;
7350 char *kwnames[] = {
7351 (char *) "self", NULL
7352 };
7353
7354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7356 if (SWIG_arg_fail(1)) SWIG_fail;
7357 {
7358 PyThreadState* __tstate = wxPyBeginAllowThreads();
7359 delete arg1;
7360
7361 wxPyEndAllowThreads(__tstate);
7362 if (PyErr_Occurred()) SWIG_fail;
7363 }
7364 Py_INCREF(Py_None); resultobj = Py_None;
7365 return resultobj;
7366 fail:
7367 return NULL;
7368 }
7369
7370
7371 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7372 PyObject *resultobj;
7373 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7374 PyObject * obj0 = 0 ;
7375 char *kwnames[] = {
7376 (char *) "self", NULL
7377 };
7378
7379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7381 if (SWIG_arg_fail(1)) SWIG_fail;
7382 {
7383 PyThreadState* __tstate = wxPyBeginAllowThreads();
7384 (arg1)->close();
7385
7386 wxPyEndAllowThreads(__tstate);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 Py_INCREF(Py_None); resultobj = Py_None;
7390 return resultobj;
7391 fail:
7392 return NULL;
7393 }
7394
7395
7396 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7397 PyObject *resultobj;
7398 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7399 PyObject * obj0 = 0 ;
7400 char *kwnames[] = {
7401 (char *) "self", NULL
7402 };
7403
7404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7406 if (SWIG_arg_fail(1)) SWIG_fail;
7407 {
7408 PyThreadState* __tstate = wxPyBeginAllowThreads();
7409 (arg1)->flush();
7410
7411 wxPyEndAllowThreads(__tstate);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 Py_INCREF(Py_None); resultobj = Py_None;
7415 return resultobj;
7416 fail:
7417 return NULL;
7418 }
7419
7420
7421 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7422 PyObject *resultobj;
7423 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7424 bool result;
7425 PyObject * obj0 = 0 ;
7426 char *kwnames[] = {
7427 (char *) "self", NULL
7428 };
7429
7430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7432 if (SWIG_arg_fail(1)) SWIG_fail;
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 result = (bool)(arg1)->eof();
7436
7437 wxPyEndAllowThreads(__tstate);
7438 if (PyErr_Occurred()) SWIG_fail;
7439 }
7440 {
7441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7442 }
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj;
7451 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7452 int arg2 = (int) -1 ;
7453 PyObject *result;
7454 PyObject * obj0 = 0 ;
7455 PyObject * obj1 = 0 ;
7456 char *kwnames[] = {
7457 (char *) "self",(char *) "size", NULL
7458 };
7459
7460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7462 if (SWIG_arg_fail(1)) SWIG_fail;
7463 if (obj1) {
7464 {
7465 arg2 = (int)(SWIG_As_int(obj1));
7466 if (SWIG_arg_fail(2)) SWIG_fail;
7467 }
7468 }
7469 {
7470 PyThreadState* __tstate = wxPyBeginAllowThreads();
7471 result = (PyObject *)(arg1)->read(arg2);
7472
7473 wxPyEndAllowThreads(__tstate);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 resultobj = result;
7477 return resultobj;
7478 fail:
7479 return NULL;
7480 }
7481
7482
7483 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7484 PyObject *resultobj;
7485 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7486 int arg2 = (int) -1 ;
7487 PyObject *result;
7488 PyObject * obj0 = 0 ;
7489 PyObject * obj1 = 0 ;
7490 char *kwnames[] = {
7491 (char *) "self",(char *) "size", NULL
7492 };
7493
7494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7496 if (SWIG_arg_fail(1)) SWIG_fail;
7497 if (obj1) {
7498 {
7499 arg2 = (int)(SWIG_As_int(obj1));
7500 if (SWIG_arg_fail(2)) SWIG_fail;
7501 }
7502 }
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 result = (PyObject *)(arg1)->readline(arg2);
7506
7507 wxPyEndAllowThreads(__tstate);
7508 if (PyErr_Occurred()) SWIG_fail;
7509 }
7510 resultobj = result;
7511 return resultobj;
7512 fail:
7513 return NULL;
7514 }
7515
7516
7517 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7518 PyObject *resultobj;
7519 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7520 int arg2 = (int) -1 ;
7521 PyObject *result;
7522 PyObject * obj0 = 0 ;
7523 PyObject * obj1 = 0 ;
7524 char *kwnames[] = {
7525 (char *) "self",(char *) "sizehint", NULL
7526 };
7527
7528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7530 if (SWIG_arg_fail(1)) SWIG_fail;
7531 if (obj1) {
7532 {
7533 arg2 = (int)(SWIG_As_int(obj1));
7534 if (SWIG_arg_fail(2)) SWIG_fail;
7535 }
7536 }
7537 {
7538 PyThreadState* __tstate = wxPyBeginAllowThreads();
7539 result = (PyObject *)(arg1)->readlines(arg2);
7540
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 resultobj = result;
7545 return resultobj;
7546 fail:
7547 return NULL;
7548 }
7549
7550
7551 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj;
7553 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7554 int arg2 ;
7555 int arg3 = (int) 0 ;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 PyObject * obj2 = 0 ;
7559 char *kwnames[] = {
7560 (char *) "self",(char *) "offset",(char *) "whence", NULL
7561 };
7562
7563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(1)) SWIG_fail;
7566 {
7567 arg2 = (int)(SWIG_As_int(obj1));
7568 if (SWIG_arg_fail(2)) SWIG_fail;
7569 }
7570 if (obj2) {
7571 {
7572 arg3 = (int)(SWIG_As_int(obj2));
7573 if (SWIG_arg_fail(3)) SWIG_fail;
7574 }
7575 }
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 (arg1)->seek(arg2,arg3);
7579
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 Py_INCREF(Py_None); resultobj = Py_None;
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj;
7592 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7593 int result;
7594 PyObject * obj0 = 0 ;
7595 char *kwnames[] = {
7596 (char *) "self", NULL
7597 };
7598
7599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7601 if (SWIG_arg_fail(1)) SWIG_fail;
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 result = (int)(arg1)->tell();
7605
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 {
7610 resultobj = SWIG_From_int((int)(result));
7611 }
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7619 PyObject *resultobj;
7620 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7621 char result;
7622 PyObject * obj0 = 0 ;
7623 char *kwnames[] = {
7624 (char *) "self", NULL
7625 };
7626
7627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7629 if (SWIG_arg_fail(1)) SWIG_fail;
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 result = (char)(arg1)->Peek();
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 {
7638 resultobj = SWIG_From_char((char)(result));
7639 }
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj;
7648 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7649 char result;
7650 PyObject * obj0 = 0 ;
7651 char *kwnames[] = {
7652 (char *) "self", NULL
7653 };
7654
7655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7657 if (SWIG_arg_fail(1)) SWIG_fail;
7658 {
7659 PyThreadState* __tstate = wxPyBeginAllowThreads();
7660 result = (char)(arg1)->GetC();
7661
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 {
7666 resultobj = SWIG_From_char((char)(result));
7667 }
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj;
7676 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7677 size_t result;
7678 PyObject * obj0 = 0 ;
7679 char *kwnames[] = {
7680 (char *) "self", NULL
7681 };
7682
7683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7685 if (SWIG_arg_fail(1)) SWIG_fail;
7686 {
7687 PyThreadState* __tstate = wxPyBeginAllowThreads();
7688 result = (size_t)(arg1)->LastRead();
7689
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 {
7694 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7695 }
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj;
7704 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7705 bool result;
7706 PyObject * obj0 = 0 ;
7707 char *kwnames[] = {
7708 (char *) "self", NULL
7709 };
7710
7711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7713 if (SWIG_arg_fail(1)) SWIG_fail;
7714 {
7715 PyThreadState* __tstate = wxPyBeginAllowThreads();
7716 result = (bool)(arg1)->CanRead();
7717
7718 wxPyEndAllowThreads(__tstate);
7719 if (PyErr_Occurred()) SWIG_fail;
7720 }
7721 {
7722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7723 }
7724 return resultobj;
7725 fail:
7726 return NULL;
7727 }
7728
7729
7730 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7731 PyObject *resultobj;
7732 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7733 bool result;
7734 PyObject * obj0 = 0 ;
7735 char *kwnames[] = {
7736 (char *) "self", NULL
7737 };
7738
7739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7741 if (SWIG_arg_fail(1)) SWIG_fail;
7742 {
7743 PyThreadState* __tstate = wxPyBeginAllowThreads();
7744 result = (bool)(arg1)->Eof();
7745
7746 wxPyEndAllowThreads(__tstate);
7747 if (PyErr_Occurred()) SWIG_fail;
7748 }
7749 {
7750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7751 }
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj;
7760 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7761 char arg2 ;
7762 bool result;
7763 PyObject * obj0 = 0 ;
7764 PyObject * obj1 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self",(char *) "c", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 arg2 = (char)(SWIG_As_char(obj1));
7774 if (SWIG_arg_fail(2)) SWIG_fail;
7775 }
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 result = (bool)(arg1)->Ungetch(arg2);
7779
7780 wxPyEndAllowThreads(__tstate);
7781 if (PyErr_Occurred()) SWIG_fail;
7782 }
7783 {
7784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7785 }
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7793 PyObject *resultobj;
7794 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7795 long arg2 ;
7796 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7797 long result;
7798 PyObject * obj0 = 0 ;
7799 PyObject * obj1 = 0 ;
7800 PyObject * obj2 = 0 ;
7801 char *kwnames[] = {
7802 (char *) "self",(char *) "pos",(char *) "mode", NULL
7803 };
7804
7805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7807 if (SWIG_arg_fail(1)) SWIG_fail;
7808 {
7809 arg2 = (long)(SWIG_As_long(obj1));
7810 if (SWIG_arg_fail(2)) SWIG_fail;
7811 }
7812 if (obj2) {
7813 {
7814 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7815 if (SWIG_arg_fail(3)) SWIG_fail;
7816 }
7817 }
7818 {
7819 PyThreadState* __tstate = wxPyBeginAllowThreads();
7820 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7821
7822 wxPyEndAllowThreads(__tstate);
7823 if (PyErr_Occurred()) SWIG_fail;
7824 }
7825 {
7826 resultobj = SWIG_From_long((long)(result));
7827 }
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7835 PyObject *resultobj;
7836 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7837 long result;
7838 PyObject * obj0 = 0 ;
7839 char *kwnames[] = {
7840 (char *) "self", NULL
7841 };
7842
7843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7845 if (SWIG_arg_fail(1)) SWIG_fail;
7846 {
7847 PyThreadState* __tstate = wxPyBeginAllowThreads();
7848 result = (long)(arg1)->TellI();
7849
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 {
7854 resultobj = SWIG_From_long((long)(result));
7855 }
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7863 PyObject *obj;
7864 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7865 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7866 Py_INCREF(obj);
7867 return Py_BuildValue((char *)"");
7868 }
7869 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7870 PyObject *resultobj;
7871 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7872 PyObject *arg2 = (PyObject *) 0 ;
7873 PyObject * obj0 = 0 ;
7874 PyObject * obj1 = 0 ;
7875 char *kwnames[] = {
7876 (char *) "self",(char *) "obj", NULL
7877 };
7878
7879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7881 if (SWIG_arg_fail(1)) SWIG_fail;
7882 arg2 = obj1;
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 wxOutputStream_write(arg1,arg2);
7886
7887 wxPyEndAllowThreads(__tstate);
7888 if (PyErr_Occurred()) SWIG_fail;
7889 }
7890 Py_INCREF(Py_None); resultobj = Py_None;
7891 return resultobj;
7892 fail:
7893 return NULL;
7894 }
7895
7896
7897 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7898 PyObject *obj;
7899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7900 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7901 Py_INCREF(obj);
7902 return Py_BuildValue((char *)"");
7903 }
7904 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7905 PyObject *resultobj;
7906 wxInputStream *arg1 = (wxInputStream *) 0 ;
7907 wxString *arg2 = 0 ;
7908 wxString *arg3 = 0 ;
7909 wxString *arg4 = 0 ;
7910 wxDateTime arg5 ;
7911 wxFSFile *result;
7912 wxPyInputStream *temp1 ;
7913 bool created1 ;
7914 bool temp2 = false ;
7915 bool temp3 = false ;
7916 bool temp4 = false ;
7917 PyObject * obj0 = 0 ;
7918 PyObject * obj1 = 0 ;
7919 PyObject * obj2 = 0 ;
7920 PyObject * obj3 = 0 ;
7921 PyObject * obj4 = 0 ;
7922 char *kwnames[] = {
7923 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7924 };
7925
7926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7927 {
7928 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7929 arg1 = temp1->m_wxis;
7930 created1 = false;
7931 } else {
7932 PyErr_Clear(); // clear the failure of the wxPyConvert above
7933 arg1 = wxPyCBInputStream_create(obj0, false);
7934 if (arg1 == NULL) {
7935 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7936 SWIG_fail;
7937 }
7938 created1 = true;
7939 }
7940 }
7941 {
7942 arg2 = wxString_in_helper(obj1);
7943 if (arg2 == NULL) SWIG_fail;
7944 temp2 = true;
7945 }
7946 {
7947 arg3 = wxString_in_helper(obj2);
7948 if (arg3 == NULL) SWIG_fail;
7949 temp3 = true;
7950 }
7951 {
7952 arg4 = wxString_in_helper(obj3);
7953 if (arg4 == NULL) SWIG_fail;
7954 temp4 = true;
7955 }
7956 {
7957 wxDateTime * argp;
7958 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7959 if (SWIG_arg_fail(5)) SWIG_fail;
7960 if (argp == NULL) {
7961 SWIG_null_ref("wxDateTime");
7962 }
7963 if (SWIG_arg_fail(5)) SWIG_fail;
7964 arg5 = *argp;
7965 }
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7969
7970 wxPyEndAllowThreads(__tstate);
7971 if (PyErr_Occurred()) SWIG_fail;
7972 }
7973 {
7974 resultobj = wxPyMake_wxObject(result, 1);
7975 }
7976 {
7977 if (created1)
7978 delete arg1;
7979 }
7980 {
7981 if (temp2)
7982 delete arg2;
7983 }
7984 {
7985 if (temp3)
7986 delete arg3;
7987 }
7988 {
7989 if (temp4)
7990 delete arg4;
7991 }
7992 return resultobj;
7993 fail:
7994 {
7995 if (created1)
7996 delete arg1;
7997 }
7998 {
7999 if (temp2)
8000 delete arg2;
8001 }
8002 {
8003 if (temp3)
8004 delete arg3;
8005 }
8006 {
8007 if (temp4)
8008 delete arg4;
8009 }
8010 return NULL;
8011 }
8012
8013
8014 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8015 PyObject *resultobj;
8016 wxFSFile *arg1 = (wxFSFile *) 0 ;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "self", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8024 if (SWIG_arg_fail(1)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 delete arg1;
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 Py_INCREF(Py_None); resultobj = Py_None;
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8040 PyObject *resultobj;
8041 wxFSFile *arg1 = (wxFSFile *) 0 ;
8042 wxInputStream *result;
8043 PyObject * obj0 = 0 ;
8044 char *kwnames[] = {
8045 (char *) "self", NULL
8046 };
8047
8048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8050 if (SWIG_arg_fail(1)) SWIG_fail;
8051 {
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 result = (wxInputStream *)(arg1)->GetStream();
8054
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 {
8059 wxPyInputStream * _ptr = NULL;
8060
8061 if (result) {
8062 _ptr = new wxPyInputStream(result);
8063 }
8064 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8065 }
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj;
8074 wxFSFile *arg1 = (wxFSFile *) 0 ;
8075 wxString *result;
8076 PyObject * obj0 = 0 ;
8077 char *kwnames[] = {
8078 (char *) "self", NULL
8079 };
8080
8081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8083 if (SWIG_arg_fail(1)) SWIG_fail;
8084 {
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 {
8087 wxString const &_result_ref = (arg1)->GetMimeType();
8088 result = (wxString *) &_result_ref;
8089 }
8090
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 {
8095 #if wxUSE_UNICODE
8096 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8097 #else
8098 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8099 #endif
8100 }
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8108 PyObject *resultobj;
8109 wxFSFile *arg1 = (wxFSFile *) 0 ;
8110 wxString *result;
8111 PyObject * obj0 = 0 ;
8112 char *kwnames[] = {
8113 (char *) "self", NULL
8114 };
8115
8116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8118 if (SWIG_arg_fail(1)) SWIG_fail;
8119 {
8120 PyThreadState* __tstate = wxPyBeginAllowThreads();
8121 {
8122 wxString const &_result_ref = (arg1)->GetLocation();
8123 result = (wxString *) &_result_ref;
8124 }
8125
8126 wxPyEndAllowThreads(__tstate);
8127 if (PyErr_Occurred()) SWIG_fail;
8128 }
8129 {
8130 #if wxUSE_UNICODE
8131 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8132 #else
8133 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8134 #endif
8135 }
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8143 PyObject *resultobj;
8144 wxFSFile *arg1 = (wxFSFile *) 0 ;
8145 wxString *result;
8146 PyObject * obj0 = 0 ;
8147 char *kwnames[] = {
8148 (char *) "self", NULL
8149 };
8150
8151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8153 if (SWIG_arg_fail(1)) SWIG_fail;
8154 {
8155 PyThreadState* __tstate = wxPyBeginAllowThreads();
8156 {
8157 wxString const &_result_ref = (arg1)->GetAnchor();
8158 result = (wxString *) &_result_ref;
8159 }
8160
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 {
8165 #if wxUSE_UNICODE
8166 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8167 #else
8168 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8169 #endif
8170 }
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj;
8179 wxFSFile *arg1 = (wxFSFile *) 0 ;
8180 wxDateTime result;
8181 PyObject * obj0 = 0 ;
8182 char *kwnames[] = {
8183 (char *) "self", NULL
8184 };
8185
8186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8188 if (SWIG_arg_fail(1)) SWIG_fail;
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 result = (arg1)->GetModificationTime();
8192
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 {
8197 wxDateTime * resultptr;
8198 resultptr = new wxDateTime((wxDateTime &)(result));
8199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8208 PyObject *obj;
8209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8210 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8211 Py_INCREF(obj);
8212 return Py_BuildValue((char *)"");
8213 }
8214 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8215 PyObject *obj;
8216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8217 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8218 Py_INCREF(obj);
8219 return Py_BuildValue((char *)"");
8220 }
8221 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8222 PyObject *resultobj;
8223 wxPyFileSystemHandler *result;
8224 char *kwnames[] = {
8225 NULL
8226 };
8227
8228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8232
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj;
8245 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8246 PyObject *arg2 = (PyObject *) 0 ;
8247 PyObject *arg3 = (PyObject *) 0 ;
8248 PyObject * obj0 = 0 ;
8249 PyObject * obj1 = 0 ;
8250 PyObject * obj2 = 0 ;
8251 char *kwnames[] = {
8252 (char *) "self",(char *) "self",(char *) "_class", NULL
8253 };
8254
8255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8257 if (SWIG_arg_fail(1)) SWIG_fail;
8258 arg2 = obj1;
8259 arg3 = obj2;
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 (arg1)->_setCallbackInfo(arg2,arg3);
8263
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 Py_INCREF(Py_None); resultobj = Py_None;
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj;
8276 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8277 wxString *arg2 = 0 ;
8278 bool result;
8279 bool temp2 = false ;
8280 PyObject * obj0 = 0 ;
8281 PyObject * obj1 = 0 ;
8282 char *kwnames[] = {
8283 (char *) "self",(char *) "location", NULL
8284 };
8285
8286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8288 if (SWIG_arg_fail(1)) SWIG_fail;
8289 {
8290 arg2 = wxString_in_helper(obj1);
8291 if (arg2 == NULL) SWIG_fail;
8292 temp2 = true;
8293 }
8294 {
8295 PyThreadState* __tstate = wxPyBeginAllowThreads();
8296 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8297
8298 wxPyEndAllowThreads(__tstate);
8299 if (PyErr_Occurred()) SWIG_fail;
8300 }
8301 {
8302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8303 }
8304 {
8305 if (temp2)
8306 delete arg2;
8307 }
8308 return resultobj;
8309 fail:
8310 {
8311 if (temp2)
8312 delete arg2;
8313 }
8314 return NULL;
8315 }
8316
8317
8318 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj;
8320 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8321 wxFileSystem *arg2 = 0 ;
8322 wxString *arg3 = 0 ;
8323 wxFSFile *result;
8324 bool temp3 = false ;
8325 PyObject * obj0 = 0 ;
8326 PyObject * obj1 = 0 ;
8327 PyObject * obj2 = 0 ;
8328 char *kwnames[] = {
8329 (char *) "self",(char *) "fs",(char *) "location", NULL
8330 };
8331
8332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8334 if (SWIG_arg_fail(1)) SWIG_fail;
8335 {
8336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8337 if (SWIG_arg_fail(2)) SWIG_fail;
8338 if (arg2 == NULL) {
8339 SWIG_null_ref("wxFileSystem");
8340 }
8341 if (SWIG_arg_fail(2)) SWIG_fail;
8342 }
8343 {
8344 arg3 = wxString_in_helper(obj2);
8345 if (arg3 == NULL) SWIG_fail;
8346 temp3 = true;
8347 }
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8351
8352 wxPyEndAllowThreads(__tstate);
8353 if (PyErr_Occurred()) SWIG_fail;
8354 }
8355 {
8356 resultobj = wxPyMake_wxObject(result, 1);
8357 }
8358 {
8359 if (temp3)
8360 delete arg3;
8361 }
8362 return resultobj;
8363 fail:
8364 {
8365 if (temp3)
8366 delete arg3;
8367 }
8368 return NULL;
8369 }
8370
8371
8372 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8373 PyObject *resultobj;
8374 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8375 wxString *arg2 = 0 ;
8376 int arg3 = (int) 0 ;
8377 wxString result;
8378 bool temp2 = false ;
8379 PyObject * obj0 = 0 ;
8380 PyObject * obj1 = 0 ;
8381 PyObject * obj2 = 0 ;
8382 char *kwnames[] = {
8383 (char *) "self",(char *) "spec",(char *) "flags", NULL
8384 };
8385
8386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8388 if (SWIG_arg_fail(1)) SWIG_fail;
8389 {
8390 arg2 = wxString_in_helper(obj1);
8391 if (arg2 == NULL) SWIG_fail;
8392 temp2 = true;
8393 }
8394 if (obj2) {
8395 {
8396 arg3 = (int)(SWIG_As_int(obj2));
8397 if (SWIG_arg_fail(3)) SWIG_fail;
8398 }
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8403
8404 wxPyEndAllowThreads(__tstate);
8405 if (PyErr_Occurred()) SWIG_fail;
8406 }
8407 {
8408 #if wxUSE_UNICODE
8409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8410 #else
8411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8412 #endif
8413 }
8414 {
8415 if (temp2)
8416 delete arg2;
8417 }
8418 return resultobj;
8419 fail:
8420 {
8421 if (temp2)
8422 delete arg2;
8423 }
8424 return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8429 PyObject *resultobj;
8430 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8431 wxString result;
8432 PyObject * obj0 = 0 ;
8433 char *kwnames[] = {
8434 (char *) "self", NULL
8435 };
8436
8437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8439 if (SWIG_arg_fail(1)) SWIG_fail;
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (arg1)->FindNext();
8443
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 {
8448 #if wxUSE_UNICODE
8449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8450 #else
8451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8452 #endif
8453 }
8454 return resultobj;
8455 fail:
8456 return NULL;
8457 }
8458
8459
8460 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8461 PyObject *resultobj;
8462 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8463 wxString *arg2 = 0 ;
8464 wxString result;
8465 bool temp2 = false ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 char *kwnames[] = {
8469 (char *) "self",(char *) "location", NULL
8470 };
8471
8472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8474 if (SWIG_arg_fail(1)) SWIG_fail;
8475 {
8476 arg2 = wxString_in_helper(obj1);
8477 if (arg2 == NULL) SWIG_fail;
8478 temp2 = true;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (arg1)->GetProtocol((wxString const &)*arg2);
8483
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 {
8488 #if wxUSE_UNICODE
8489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8490 #else
8491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8492 #endif
8493 }
8494 {
8495 if (temp2)
8496 delete arg2;
8497 }
8498 return resultobj;
8499 fail:
8500 {
8501 if (temp2)
8502 delete arg2;
8503 }
8504 return NULL;
8505 }
8506
8507
8508 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj;
8510 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8511 wxString *arg2 = 0 ;
8512 wxString result;
8513 bool temp2 = false ;
8514 PyObject * obj0 = 0 ;
8515 PyObject * obj1 = 0 ;
8516 char *kwnames[] = {
8517 (char *) "self",(char *) "location", NULL
8518 };
8519
8520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8522 if (SWIG_arg_fail(1)) SWIG_fail;
8523 {
8524 arg2 = wxString_in_helper(obj1);
8525 if (arg2 == NULL) SWIG_fail;
8526 temp2 = true;
8527 }
8528 {
8529 PyThreadState* __tstate = wxPyBeginAllowThreads();
8530 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8531
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 #if wxUSE_UNICODE
8537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8538 #else
8539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8540 #endif
8541 }
8542 {
8543 if (temp2)
8544 delete arg2;
8545 }
8546 return resultobj;
8547 fail:
8548 {
8549 if (temp2)
8550 delete arg2;
8551 }
8552 return NULL;
8553 }
8554
8555
8556 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj;
8558 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8559 wxString *arg2 = 0 ;
8560 wxString result;
8561 bool temp2 = false ;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 char *kwnames[] = {
8565 (char *) "self",(char *) "location", NULL
8566 };
8567
8568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8570 if (SWIG_arg_fail(1)) SWIG_fail;
8571 {
8572 arg2 = wxString_in_helper(obj1);
8573 if (arg2 == NULL) SWIG_fail;
8574 temp2 = true;
8575 }
8576 {
8577 PyThreadState* __tstate = wxPyBeginAllowThreads();
8578 result = (arg1)->GetAnchor((wxString const &)*arg2);
8579
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 {
8584 #if wxUSE_UNICODE
8585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8586 #else
8587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8588 #endif
8589 }
8590 {
8591 if (temp2)
8592 delete arg2;
8593 }
8594 return resultobj;
8595 fail:
8596 {
8597 if (temp2)
8598 delete arg2;
8599 }
8600 return NULL;
8601 }
8602
8603
8604 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8605 PyObject *resultobj;
8606 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8607 wxString *arg2 = 0 ;
8608 wxString result;
8609 bool temp2 = false ;
8610 PyObject * obj0 = 0 ;
8611 PyObject * obj1 = 0 ;
8612 char *kwnames[] = {
8613 (char *) "self",(char *) "location", NULL
8614 };
8615
8616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8618 if (SWIG_arg_fail(1)) SWIG_fail;
8619 {
8620 arg2 = wxString_in_helper(obj1);
8621 if (arg2 == NULL) SWIG_fail;
8622 temp2 = true;
8623 }
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8627
8628 wxPyEndAllowThreads(__tstate);
8629 if (PyErr_Occurred()) SWIG_fail;
8630 }
8631 {
8632 #if wxUSE_UNICODE
8633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8634 #else
8635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8636 #endif
8637 }
8638 {
8639 if (temp2)
8640 delete arg2;
8641 }
8642 return resultobj;
8643 fail:
8644 {
8645 if (temp2)
8646 delete arg2;
8647 }
8648 return NULL;
8649 }
8650
8651
8652 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8653 PyObject *resultobj;
8654 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8655 wxString *arg2 = 0 ;
8656 wxString result;
8657 bool temp2 = false ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char *kwnames[] = {
8661 (char *) "self",(char *) "location", NULL
8662 };
8663
8664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8666 if (SWIG_arg_fail(1)) SWIG_fail;
8667 {
8668 arg2 = wxString_in_helper(obj1);
8669 if (arg2 == NULL) SWIG_fail;
8670 temp2 = true;
8671 }
8672 {
8673 PyThreadState* __tstate = wxPyBeginAllowThreads();
8674 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8675
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 {
8680 #if wxUSE_UNICODE
8681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8682 #else
8683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8684 #endif
8685 }
8686 {
8687 if (temp2)
8688 delete arg2;
8689 }
8690 return resultobj;
8691 fail:
8692 {
8693 if (temp2)
8694 delete arg2;
8695 }
8696 return NULL;
8697 }
8698
8699
8700 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8701 PyObject *obj;
8702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8703 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8704 Py_INCREF(obj);
8705 return Py_BuildValue((char *)"");
8706 }
8707 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8708 PyObject *resultobj;
8709 wxFileSystem *result;
8710 char *kwnames[] = {
8711 NULL
8712 };
8713
8714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8715 {
8716 PyThreadState* __tstate = wxPyBeginAllowThreads();
8717 result = (wxFileSystem *)new wxFileSystem();
8718
8719 wxPyEndAllowThreads(__tstate);
8720 if (PyErr_Occurred()) SWIG_fail;
8721 }
8722 {
8723 resultobj = wxPyMake_wxObject(result, 1);
8724 }
8725 return resultobj;
8726 fail:
8727 return NULL;
8728 }
8729
8730
8731 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8732 PyObject *resultobj;
8733 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8734 PyObject * obj0 = 0 ;
8735 char *kwnames[] = {
8736 (char *) "self", NULL
8737 };
8738
8739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8741 if (SWIG_arg_fail(1)) SWIG_fail;
8742 {
8743 PyThreadState* __tstate = wxPyBeginAllowThreads();
8744 delete arg1;
8745
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 Py_INCREF(Py_None); resultobj = Py_None;
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8757 PyObject *resultobj;
8758 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8759 wxString *arg2 = 0 ;
8760 bool arg3 = (bool) false ;
8761 bool temp2 = false ;
8762 PyObject * obj0 = 0 ;
8763 PyObject * obj1 = 0 ;
8764 PyObject * obj2 = 0 ;
8765 char *kwnames[] = {
8766 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8767 };
8768
8769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8771 if (SWIG_arg_fail(1)) SWIG_fail;
8772 {
8773 arg2 = wxString_in_helper(obj1);
8774 if (arg2 == NULL) SWIG_fail;
8775 temp2 = true;
8776 }
8777 if (obj2) {
8778 {
8779 arg3 = (bool)(SWIG_As_bool(obj2));
8780 if (SWIG_arg_fail(3)) SWIG_fail;
8781 }
8782 }
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8786
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 Py_INCREF(Py_None); resultobj = Py_None;
8791 {
8792 if (temp2)
8793 delete arg2;
8794 }
8795 return resultobj;
8796 fail:
8797 {
8798 if (temp2)
8799 delete arg2;
8800 }
8801 return NULL;
8802 }
8803
8804
8805 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8806 PyObject *resultobj;
8807 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8808 wxString result;
8809 PyObject * obj0 = 0 ;
8810 char *kwnames[] = {
8811 (char *) "self", NULL
8812 };
8813
8814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8816 if (SWIG_arg_fail(1)) SWIG_fail;
8817 {
8818 PyThreadState* __tstate = wxPyBeginAllowThreads();
8819 result = (arg1)->GetPath();
8820
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 {
8825 #if wxUSE_UNICODE
8826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8827 #else
8828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8829 #endif
8830 }
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj;
8839 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8840 wxString *arg2 = 0 ;
8841 wxFSFile *result;
8842 bool temp2 = false ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 char *kwnames[] = {
8846 (char *) "self",(char *) "location", NULL
8847 };
8848
8849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8851 if (SWIG_arg_fail(1)) SWIG_fail;
8852 {
8853 arg2 = wxString_in_helper(obj1);
8854 if (arg2 == NULL) SWIG_fail;
8855 temp2 = true;
8856 }
8857 {
8858 PyThreadState* __tstate = wxPyBeginAllowThreads();
8859 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8860
8861 wxPyEndAllowThreads(__tstate);
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 {
8865 resultobj = wxPyMake_wxObject(result, 1);
8866 }
8867 {
8868 if (temp2)
8869 delete arg2;
8870 }
8871 return resultobj;
8872 fail:
8873 {
8874 if (temp2)
8875 delete arg2;
8876 }
8877 return NULL;
8878 }
8879
8880
8881 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8882 PyObject *resultobj;
8883 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8884 wxString *arg2 = 0 ;
8885 int arg3 = (int) 0 ;
8886 wxString result;
8887 bool temp2 = false ;
8888 PyObject * obj0 = 0 ;
8889 PyObject * obj1 = 0 ;
8890 PyObject * obj2 = 0 ;
8891 char *kwnames[] = {
8892 (char *) "self",(char *) "spec",(char *) "flags", NULL
8893 };
8894
8895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8897 if (SWIG_arg_fail(1)) SWIG_fail;
8898 {
8899 arg2 = wxString_in_helper(obj1);
8900 if (arg2 == NULL) SWIG_fail;
8901 temp2 = true;
8902 }
8903 if (obj2) {
8904 {
8905 arg3 = (int)(SWIG_As_int(obj2));
8906 if (SWIG_arg_fail(3)) SWIG_fail;
8907 }
8908 }
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8912
8913 wxPyEndAllowThreads(__tstate);
8914 if (PyErr_Occurred()) SWIG_fail;
8915 }
8916 {
8917 #if wxUSE_UNICODE
8918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8919 #else
8920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8921 #endif
8922 }
8923 {
8924 if (temp2)
8925 delete arg2;
8926 }
8927 return resultobj;
8928 fail:
8929 {
8930 if (temp2)
8931 delete arg2;
8932 }
8933 return NULL;
8934 }
8935
8936
8937 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8938 PyObject *resultobj;
8939 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8940 wxString result;
8941 PyObject * obj0 = 0 ;
8942 char *kwnames[] = {
8943 (char *) "self", NULL
8944 };
8945
8946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8948 if (SWIG_arg_fail(1)) SWIG_fail;
8949 {
8950 PyThreadState* __tstate = wxPyBeginAllowThreads();
8951 result = (arg1)->FindNext();
8952
8953 wxPyEndAllowThreads(__tstate);
8954 if (PyErr_Occurred()) SWIG_fail;
8955 }
8956 {
8957 #if wxUSE_UNICODE
8958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8959 #else
8960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8961 #endif
8962 }
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8970 PyObject *resultobj;
8971 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8972 PyObject * obj0 = 0 ;
8973 char *kwnames[] = {
8974 (char *) "handler", NULL
8975 };
8976
8977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8979 if (SWIG_arg_fail(1)) SWIG_fail;
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 wxFileSystem::AddHandler(arg1);
8983
8984 wxPyEndAllowThreads(__tstate);
8985 if (PyErr_Occurred()) SWIG_fail;
8986 }
8987 Py_INCREF(Py_None); resultobj = Py_None;
8988 return resultobj;
8989 fail:
8990 return NULL;
8991 }
8992
8993
8994 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8995 PyObject *resultobj;
8996 char *kwnames[] = {
8997 NULL
8998 };
8999
9000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 wxFileSystem::CleanUpHandlers();
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 Py_INCREF(Py_None); resultobj = Py_None;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj;
9017 wxString *arg1 = 0 ;
9018 wxString result;
9019 bool temp1 = false ;
9020 PyObject * obj0 = 0 ;
9021 char *kwnames[] = {
9022 (char *) "filename", NULL
9023 };
9024
9025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9026 {
9027 arg1 = wxString_in_helper(obj0);
9028 if (arg1 == NULL) SWIG_fail;
9029 temp1 = true;
9030 }
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9034
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 {
9039 #if wxUSE_UNICODE
9040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9041 #else
9042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9043 #endif
9044 }
9045 {
9046 if (temp1)
9047 delete arg1;
9048 }
9049 return resultobj;
9050 fail:
9051 {
9052 if (temp1)
9053 delete arg1;
9054 }
9055 return NULL;
9056 }
9057
9058
9059 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9060 PyObject *resultobj;
9061 wxString *arg1 = 0 ;
9062 wxString result;
9063 bool temp1 = false ;
9064 PyObject * obj0 = 0 ;
9065 char *kwnames[] = {
9066 (char *) "url", NULL
9067 };
9068
9069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9070 {
9071 arg1 = wxString_in_helper(obj0);
9072 if (arg1 == NULL) SWIG_fail;
9073 temp1 = true;
9074 }
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 result = FileSystem_URLToFileName((wxString const &)*arg1);
9078
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 {
9083 #if wxUSE_UNICODE
9084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9085 #else
9086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9087 #endif
9088 }
9089 {
9090 if (temp1)
9091 delete arg1;
9092 }
9093 return resultobj;
9094 fail:
9095 {
9096 if (temp1)
9097 delete arg1;
9098 }
9099 return NULL;
9100 }
9101
9102
9103 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9104 PyObject *obj;
9105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9106 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9107 Py_INCREF(obj);
9108 return Py_BuildValue((char *)"");
9109 }
9110 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxInternetFSHandler *result;
9113 char *kwnames[] = {
9114 NULL
9115 };
9116
9117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9121
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9126 return resultobj;
9127 fail:
9128 return NULL;
9129 }
9130
9131
9132 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9133 PyObject *resultobj;
9134 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9135 wxString *arg2 = 0 ;
9136 bool result;
9137 bool temp2 = false ;
9138 PyObject * obj0 = 0 ;
9139 PyObject * obj1 = 0 ;
9140 char *kwnames[] = {
9141 (char *) "self",(char *) "location", NULL
9142 };
9143
9144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9146 if (SWIG_arg_fail(1)) SWIG_fail;
9147 {
9148 arg2 = wxString_in_helper(obj1);
9149 if (arg2 == NULL) SWIG_fail;
9150 temp2 = true;
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 {
9160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9161 }
9162 {
9163 if (temp2)
9164 delete arg2;
9165 }
9166 return resultobj;
9167 fail:
9168 {
9169 if (temp2)
9170 delete arg2;
9171 }
9172 return NULL;
9173 }
9174
9175
9176 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj;
9178 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9179 wxFileSystem *arg2 = 0 ;
9180 wxString *arg3 = 0 ;
9181 wxFSFile *result;
9182 bool temp3 = false ;
9183 PyObject * obj0 = 0 ;
9184 PyObject * obj1 = 0 ;
9185 PyObject * obj2 = 0 ;
9186 char *kwnames[] = {
9187 (char *) "self",(char *) "fs",(char *) "location", NULL
9188 };
9189
9190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9192 if (SWIG_arg_fail(1)) SWIG_fail;
9193 {
9194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9195 if (SWIG_arg_fail(2)) SWIG_fail;
9196 if (arg2 == NULL) {
9197 SWIG_null_ref("wxFileSystem");
9198 }
9199 if (SWIG_arg_fail(2)) SWIG_fail;
9200 }
9201 {
9202 arg3 = wxString_in_helper(obj2);
9203 if (arg3 == NULL) SWIG_fail;
9204 temp3 = true;
9205 }
9206 {
9207 PyThreadState* __tstate = wxPyBeginAllowThreads();
9208 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9209
9210 wxPyEndAllowThreads(__tstate);
9211 if (PyErr_Occurred()) SWIG_fail;
9212 }
9213 {
9214 resultobj = wxPyMake_wxObject(result, 1);
9215 }
9216 {
9217 if (temp3)
9218 delete arg3;
9219 }
9220 return resultobj;
9221 fail:
9222 {
9223 if (temp3)
9224 delete arg3;
9225 }
9226 return NULL;
9227 }
9228
9229
9230 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9231 PyObject *obj;
9232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9233 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9234 Py_INCREF(obj);
9235 return Py_BuildValue((char *)"");
9236 }
9237 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9238 PyObject *resultobj;
9239 wxZipFSHandler *result;
9240 char *kwnames[] = {
9241 NULL
9242 };
9243
9244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (wxZipFSHandler *)new wxZipFSHandler();
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj;
9261 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9262 wxString *arg2 = 0 ;
9263 bool result;
9264 bool temp2 = false ;
9265 PyObject * obj0 = 0 ;
9266 PyObject * obj1 = 0 ;
9267 char *kwnames[] = {
9268 (char *) "self",(char *) "location", NULL
9269 };
9270
9271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9273 if (SWIG_arg_fail(1)) SWIG_fail;
9274 {
9275 arg2 = wxString_in_helper(obj1);
9276 if (arg2 == NULL) SWIG_fail;
9277 temp2 = true;
9278 }
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9282
9283 wxPyEndAllowThreads(__tstate);
9284 if (PyErr_Occurred()) SWIG_fail;
9285 }
9286 {
9287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9288 }
9289 {
9290 if (temp2)
9291 delete arg2;
9292 }
9293 return resultobj;
9294 fail:
9295 {
9296 if (temp2)
9297 delete arg2;
9298 }
9299 return NULL;
9300 }
9301
9302
9303 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj;
9305 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9306 wxFileSystem *arg2 = 0 ;
9307 wxString *arg3 = 0 ;
9308 wxFSFile *result;
9309 bool temp3 = false ;
9310 PyObject * obj0 = 0 ;
9311 PyObject * obj1 = 0 ;
9312 PyObject * obj2 = 0 ;
9313 char *kwnames[] = {
9314 (char *) "self",(char *) "fs",(char *) "location", NULL
9315 };
9316
9317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9319 if (SWIG_arg_fail(1)) SWIG_fail;
9320 {
9321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9322 if (SWIG_arg_fail(2)) SWIG_fail;
9323 if (arg2 == NULL) {
9324 SWIG_null_ref("wxFileSystem");
9325 }
9326 if (SWIG_arg_fail(2)) SWIG_fail;
9327 }
9328 {
9329 arg3 = wxString_in_helper(obj2);
9330 if (arg3 == NULL) SWIG_fail;
9331 temp3 = true;
9332 }
9333 {
9334 PyThreadState* __tstate = wxPyBeginAllowThreads();
9335 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9336
9337 wxPyEndAllowThreads(__tstate);
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 {
9341 resultobj = wxPyMake_wxObject(result, 1);
9342 }
9343 {
9344 if (temp3)
9345 delete arg3;
9346 }
9347 return resultobj;
9348 fail:
9349 {
9350 if (temp3)
9351 delete arg3;
9352 }
9353 return NULL;
9354 }
9355
9356
9357 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9358 PyObject *resultobj;
9359 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9360 wxString *arg2 = 0 ;
9361 int arg3 = (int) 0 ;
9362 wxString result;
9363 bool temp2 = false ;
9364 PyObject * obj0 = 0 ;
9365 PyObject * obj1 = 0 ;
9366 PyObject * obj2 = 0 ;
9367 char *kwnames[] = {
9368 (char *) "self",(char *) "spec",(char *) "flags", NULL
9369 };
9370
9371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9373 if (SWIG_arg_fail(1)) SWIG_fail;
9374 {
9375 arg2 = wxString_in_helper(obj1);
9376 if (arg2 == NULL) SWIG_fail;
9377 temp2 = true;
9378 }
9379 if (obj2) {
9380 {
9381 arg3 = (int)(SWIG_As_int(obj2));
9382 if (SWIG_arg_fail(3)) SWIG_fail;
9383 }
9384 }
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9388
9389 wxPyEndAllowThreads(__tstate);
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 {
9393 #if wxUSE_UNICODE
9394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9395 #else
9396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9397 #endif
9398 }
9399 {
9400 if (temp2)
9401 delete arg2;
9402 }
9403 return resultobj;
9404 fail:
9405 {
9406 if (temp2)
9407 delete arg2;
9408 }
9409 return NULL;
9410 }
9411
9412
9413 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9414 PyObject *resultobj;
9415 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9416 wxString result;
9417 PyObject * obj0 = 0 ;
9418 char *kwnames[] = {
9419 (char *) "self", NULL
9420 };
9421
9422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9424 if (SWIG_arg_fail(1)) SWIG_fail;
9425 {
9426 PyThreadState* __tstate = wxPyBeginAllowThreads();
9427 result = (arg1)->FindNext();
9428
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 {
9433 #if wxUSE_UNICODE
9434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9435 #else
9436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9437 #endif
9438 }
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9446 PyObject *obj;
9447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9448 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9449 Py_INCREF(obj);
9450 return Py_BuildValue((char *)"");
9451 }
9452 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj;
9454 wxString *arg1 = 0 ;
9455 wxImage *arg2 = 0 ;
9456 long arg3 ;
9457 bool temp1 = false ;
9458 PyObject * obj0 = 0 ;
9459 PyObject * obj1 = 0 ;
9460 PyObject * obj2 = 0 ;
9461 char *kwnames[] = {
9462 (char *) "filename",(char *) "image",(char *) "type", NULL
9463 };
9464
9465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9466 {
9467 arg1 = wxString_in_helper(obj0);
9468 if (arg1 == NULL) SWIG_fail;
9469 temp1 = true;
9470 }
9471 {
9472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9473 if (SWIG_arg_fail(2)) SWIG_fail;
9474 if (arg2 == NULL) {
9475 SWIG_null_ref("wxImage");
9476 }
9477 if (SWIG_arg_fail(2)) SWIG_fail;
9478 }
9479 {
9480 arg3 = (long)(SWIG_As_long(obj2));
9481 if (SWIG_arg_fail(3)) SWIG_fail;
9482 }
9483 {
9484 PyThreadState* __tstate = wxPyBeginAllowThreads();
9485 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9486
9487 wxPyEndAllowThreads(__tstate);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 Py_INCREF(Py_None); resultobj = Py_None;
9491 {
9492 if (temp1)
9493 delete arg1;
9494 }
9495 return resultobj;
9496 fail:
9497 {
9498 if (temp1)
9499 delete arg1;
9500 }
9501 return NULL;
9502 }
9503
9504
9505 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9506 PyObject *resultobj;
9507 wxString *arg1 = 0 ;
9508 wxBitmap *arg2 = 0 ;
9509 long arg3 ;
9510 bool temp1 = false ;
9511 PyObject * obj0 = 0 ;
9512 PyObject * obj1 = 0 ;
9513 PyObject * obj2 = 0 ;
9514 char *kwnames[] = {
9515 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9516 };
9517
9518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9519 {
9520 arg1 = wxString_in_helper(obj0);
9521 if (arg1 == NULL) SWIG_fail;
9522 temp1 = true;
9523 }
9524 {
9525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9526 if (SWIG_arg_fail(2)) SWIG_fail;
9527 if (arg2 == NULL) {
9528 SWIG_null_ref("wxBitmap");
9529 }
9530 if (SWIG_arg_fail(2)) SWIG_fail;
9531 }
9532 {
9533 arg3 = (long)(SWIG_As_long(obj2));
9534 if (SWIG_arg_fail(3)) SWIG_fail;
9535 }
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9539
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 Py_INCREF(Py_None); resultobj = Py_None;
9544 {
9545 if (temp1)
9546 delete arg1;
9547 }
9548 return resultobj;
9549 fail:
9550 {
9551 if (temp1)
9552 delete arg1;
9553 }
9554 return NULL;
9555 }
9556
9557
9558 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj;
9560 wxString *arg1 = 0 ;
9561 PyObject *arg2 = (PyObject *) 0 ;
9562 bool temp1 = false ;
9563 PyObject * obj0 = 0 ;
9564 PyObject * obj1 = 0 ;
9565 char *kwnames[] = {
9566 (char *) "filename",(char *) "data", NULL
9567 };
9568
9569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9570 {
9571 arg1 = wxString_in_helper(obj0);
9572 if (arg1 == NULL) SWIG_fail;
9573 temp1 = true;
9574 }
9575 arg2 = obj1;
9576 {
9577 PyThreadState* __tstate = wxPyBeginAllowThreads();
9578 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9579
9580 wxPyEndAllowThreads(__tstate);
9581 if (PyErr_Occurred()) SWIG_fail;
9582 }
9583 Py_INCREF(Py_None); resultobj = Py_None;
9584 {
9585 if (temp1)
9586 delete arg1;
9587 }
9588 return resultobj;
9589 fail:
9590 {
9591 if (temp1)
9592 delete arg1;
9593 }
9594 return NULL;
9595 }
9596
9597
9598 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj;
9600 wxMemoryFSHandler *result;
9601 char *kwnames[] = {
9602 NULL
9603 };
9604
9605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9609
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9614 return resultobj;
9615 fail:
9616 return NULL;
9617 }
9618
9619
9620 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9621 PyObject *resultobj;
9622 wxString *arg1 = 0 ;
9623 bool temp1 = false ;
9624 PyObject * obj0 = 0 ;
9625 char *kwnames[] = {
9626 (char *) "filename", NULL
9627 };
9628
9629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9630 {
9631 arg1 = wxString_in_helper(obj0);
9632 if (arg1 == NULL) SWIG_fail;
9633 temp1 = true;
9634 }
9635 {
9636 PyThreadState* __tstate = wxPyBeginAllowThreads();
9637 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9638
9639 wxPyEndAllowThreads(__tstate);
9640 if (PyErr_Occurred()) SWIG_fail;
9641 }
9642 Py_INCREF(Py_None); resultobj = Py_None;
9643 {
9644 if (temp1)
9645 delete arg1;
9646 }
9647 return resultobj;
9648 fail:
9649 {
9650 if (temp1)
9651 delete arg1;
9652 }
9653 return NULL;
9654 }
9655
9656
9657 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj;
9659 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9660 wxString *arg2 = 0 ;
9661 bool result;
9662 bool temp2 = false ;
9663 PyObject * obj0 = 0 ;
9664 PyObject * obj1 = 0 ;
9665 char *kwnames[] = {
9666 (char *) "self",(char *) "location", NULL
9667 };
9668
9669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9671 if (SWIG_arg_fail(1)) SWIG_fail;
9672 {
9673 arg2 = wxString_in_helper(obj1);
9674 if (arg2 == NULL) SWIG_fail;
9675 temp2 = true;
9676 }
9677 {
9678 PyThreadState* __tstate = wxPyBeginAllowThreads();
9679 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9680
9681 wxPyEndAllowThreads(__tstate);
9682 if (PyErr_Occurred()) SWIG_fail;
9683 }
9684 {
9685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9686 }
9687 {
9688 if (temp2)
9689 delete arg2;
9690 }
9691 return resultobj;
9692 fail:
9693 {
9694 if (temp2)
9695 delete arg2;
9696 }
9697 return NULL;
9698 }
9699
9700
9701 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj;
9703 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9704 wxFileSystem *arg2 = 0 ;
9705 wxString *arg3 = 0 ;
9706 wxFSFile *result;
9707 bool temp3 = false ;
9708 PyObject * obj0 = 0 ;
9709 PyObject * obj1 = 0 ;
9710 PyObject * obj2 = 0 ;
9711 char *kwnames[] = {
9712 (char *) "self",(char *) "fs",(char *) "location", NULL
9713 };
9714
9715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9717 if (SWIG_arg_fail(1)) SWIG_fail;
9718 {
9719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9720 if (SWIG_arg_fail(2)) SWIG_fail;
9721 if (arg2 == NULL) {
9722 SWIG_null_ref("wxFileSystem");
9723 }
9724 if (SWIG_arg_fail(2)) SWIG_fail;
9725 }
9726 {
9727 arg3 = wxString_in_helper(obj2);
9728 if (arg3 == NULL) SWIG_fail;
9729 temp3 = true;
9730 }
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9734
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 {
9739 resultobj = wxPyMake_wxObject(result, 1);
9740 }
9741 {
9742 if (temp3)
9743 delete arg3;
9744 }
9745 return resultobj;
9746 fail:
9747 {
9748 if (temp3)
9749 delete arg3;
9750 }
9751 return NULL;
9752 }
9753
9754
9755 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj;
9757 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9758 wxString *arg2 = 0 ;
9759 int arg3 = (int) 0 ;
9760 wxString result;
9761 bool temp2 = false ;
9762 PyObject * obj0 = 0 ;
9763 PyObject * obj1 = 0 ;
9764 PyObject * obj2 = 0 ;
9765 char *kwnames[] = {
9766 (char *) "self",(char *) "spec",(char *) "flags", NULL
9767 };
9768
9769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9771 if (SWIG_arg_fail(1)) SWIG_fail;
9772 {
9773 arg2 = wxString_in_helper(obj1);
9774 if (arg2 == NULL) SWIG_fail;
9775 temp2 = true;
9776 }
9777 if (obj2) {
9778 {
9779 arg3 = (int)(SWIG_As_int(obj2));
9780 if (SWIG_arg_fail(3)) SWIG_fail;
9781 }
9782 }
9783 {
9784 PyThreadState* __tstate = wxPyBeginAllowThreads();
9785 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9786
9787 wxPyEndAllowThreads(__tstate);
9788 if (PyErr_Occurred()) SWIG_fail;
9789 }
9790 {
9791 #if wxUSE_UNICODE
9792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9793 #else
9794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9795 #endif
9796 }
9797 {
9798 if (temp2)
9799 delete arg2;
9800 }
9801 return resultobj;
9802 fail:
9803 {
9804 if (temp2)
9805 delete arg2;
9806 }
9807 return NULL;
9808 }
9809
9810
9811 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9812 PyObject *resultobj;
9813 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9814 wxString result;
9815 PyObject * obj0 = 0 ;
9816 char *kwnames[] = {
9817 (char *) "self", NULL
9818 };
9819
9820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9822 if (SWIG_arg_fail(1)) SWIG_fail;
9823 {
9824 PyThreadState* __tstate = wxPyBeginAllowThreads();
9825 result = (arg1)->FindNext();
9826
9827 wxPyEndAllowThreads(__tstate);
9828 if (PyErr_Occurred()) SWIG_fail;
9829 }
9830 {
9831 #if wxUSE_UNICODE
9832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9833 #else
9834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9835 #endif
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9844 PyObject *obj;
9845 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9846 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9847 Py_INCREF(obj);
9848 return Py_BuildValue((char *)"");
9849 }
9850 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj;
9852 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9853 wxString result;
9854 PyObject * obj0 = 0 ;
9855 char *kwnames[] = {
9856 (char *) "self", NULL
9857 };
9858
9859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9861 if (SWIG_arg_fail(1)) SWIG_fail;
9862 {
9863 PyThreadState* __tstate = wxPyBeginAllowThreads();
9864 result = (arg1)->GetName();
9865
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 {
9870 #if wxUSE_UNICODE
9871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9872 #else
9873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9874 #endif
9875 }
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9883 PyObject *resultobj;
9884 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9885 wxString result;
9886 PyObject * obj0 = 0 ;
9887 char *kwnames[] = {
9888 (char *) "self", NULL
9889 };
9890
9891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9893 if (SWIG_arg_fail(1)) SWIG_fail;
9894 {
9895 PyThreadState* __tstate = wxPyBeginAllowThreads();
9896 result = (arg1)->GetExtension();
9897
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 {
9902 #if wxUSE_UNICODE
9903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9904 #else
9905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9906 #endif
9907 }
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj;
9916 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9917 long result;
9918 PyObject * obj0 = 0 ;
9919 char *kwnames[] = {
9920 (char *) "self", NULL
9921 };
9922
9923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9925 if (SWIG_arg_fail(1)) SWIG_fail;
9926 {
9927 PyThreadState* __tstate = wxPyBeginAllowThreads();
9928 result = (long)(arg1)->GetType();
9929
9930 wxPyEndAllowThreads(__tstate);
9931 if (PyErr_Occurred()) SWIG_fail;
9932 }
9933 {
9934 resultobj = SWIG_From_long((long)(result));
9935 }
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9943 PyObject *resultobj;
9944 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9945 wxString result;
9946 PyObject * obj0 = 0 ;
9947 char *kwnames[] = {
9948 (char *) "self", NULL
9949 };
9950
9951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9953 if (SWIG_arg_fail(1)) SWIG_fail;
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (arg1)->GetMimeType();
9957
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 {
9962 #if wxUSE_UNICODE
9963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9964 #else
9965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9966 #endif
9967 }
9968 return resultobj;
9969 fail:
9970 return NULL;
9971 }
9972
9973
9974 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9975 PyObject *resultobj;
9976 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9977 wxString *arg2 = 0 ;
9978 bool result;
9979 bool temp2 = false ;
9980 PyObject * obj0 = 0 ;
9981 PyObject * obj1 = 0 ;
9982 char *kwnames[] = {
9983 (char *) "self",(char *) "name", NULL
9984 };
9985
9986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9988 if (SWIG_arg_fail(1)) SWIG_fail;
9989 {
9990 arg2 = wxString_in_helper(obj1);
9991 if (arg2 == NULL) SWIG_fail;
9992 temp2 = true;
9993 }
9994 {
9995 PyThreadState* __tstate = wxPyBeginAllowThreads();
9996 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9997
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 {
10002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10003 }
10004 {
10005 if (temp2)
10006 delete arg2;
10007 }
10008 return resultobj;
10009 fail:
10010 {
10011 if (temp2)
10012 delete arg2;
10013 }
10014 return NULL;
10015 }
10016
10017
10018 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10019 PyObject *resultobj;
10020 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10021 wxString *arg2 = 0 ;
10022 bool temp2 = false ;
10023 PyObject * obj0 = 0 ;
10024 PyObject * obj1 = 0 ;
10025 char *kwnames[] = {
10026 (char *) "self",(char *) "name", NULL
10027 };
10028
10029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10031 if (SWIG_arg_fail(1)) SWIG_fail;
10032 {
10033 arg2 = wxString_in_helper(obj1);
10034 if (arg2 == NULL) SWIG_fail;
10035 temp2 = true;
10036 }
10037 {
10038 PyThreadState* __tstate = wxPyBeginAllowThreads();
10039 (arg1)->SetName((wxString const &)*arg2);
10040
10041 wxPyEndAllowThreads(__tstate);
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 Py_INCREF(Py_None); resultobj = Py_None;
10045 {
10046 if (temp2)
10047 delete arg2;
10048 }
10049 return resultobj;
10050 fail:
10051 {
10052 if (temp2)
10053 delete arg2;
10054 }
10055 return NULL;
10056 }
10057
10058
10059 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10060 PyObject *resultobj;
10061 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10062 wxString *arg2 = 0 ;
10063 bool temp2 = false ;
10064 PyObject * obj0 = 0 ;
10065 PyObject * obj1 = 0 ;
10066 char *kwnames[] = {
10067 (char *) "self",(char *) "extension", NULL
10068 };
10069
10070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10072 if (SWIG_arg_fail(1)) SWIG_fail;
10073 {
10074 arg2 = wxString_in_helper(obj1);
10075 if (arg2 == NULL) SWIG_fail;
10076 temp2 = true;
10077 }
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 (arg1)->SetExtension((wxString const &)*arg2);
10081
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 Py_INCREF(Py_None); resultobj = Py_None;
10086 {
10087 if (temp2)
10088 delete arg2;
10089 }
10090 return resultobj;
10091 fail:
10092 {
10093 if (temp2)
10094 delete arg2;
10095 }
10096 return NULL;
10097 }
10098
10099
10100 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj;
10102 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10103 long arg2 ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 char *kwnames[] = {
10107 (char *) "self",(char *) "type", NULL
10108 };
10109
10110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10112 if (SWIG_arg_fail(1)) SWIG_fail;
10113 {
10114 arg2 = (long)(SWIG_As_long(obj1));
10115 if (SWIG_arg_fail(2)) SWIG_fail;
10116 }
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 (arg1)->SetType(arg2);
10120
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 Py_INCREF(Py_None); resultobj = Py_None;
10125 return resultobj;
10126 fail:
10127 return NULL;
10128 }
10129
10130
10131 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10132 PyObject *resultobj;
10133 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10134 wxString *arg2 = 0 ;
10135 bool temp2 = false ;
10136 PyObject * obj0 = 0 ;
10137 PyObject * obj1 = 0 ;
10138 char *kwnames[] = {
10139 (char *) "self",(char *) "mimetype", NULL
10140 };
10141
10142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10144 if (SWIG_arg_fail(1)) SWIG_fail;
10145 {
10146 arg2 = wxString_in_helper(obj1);
10147 if (arg2 == NULL) SWIG_fail;
10148 temp2 = true;
10149 }
10150 {
10151 PyThreadState* __tstate = wxPyBeginAllowThreads();
10152 (arg1)->SetMimeType((wxString const &)*arg2);
10153
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 Py_INCREF(Py_None); resultobj = Py_None;
10158 {
10159 if (temp2)
10160 delete arg2;
10161 }
10162 return resultobj;
10163 fail:
10164 {
10165 if (temp2)
10166 delete arg2;
10167 }
10168 return NULL;
10169 }
10170
10171
10172 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10173 PyObject *obj;
10174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10175 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10176 Py_INCREF(obj);
10177 return Py_BuildValue((char *)"");
10178 }
10179 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 wxImageHistogram *result;
10182 char *kwnames[] = {
10183 NULL
10184 };
10185
10186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (wxImageHistogram *)new wxImageHistogram();
10190
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10195 return resultobj;
10196 fail:
10197 return NULL;
10198 }
10199
10200
10201 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10202 PyObject *resultobj;
10203 unsigned char arg1 ;
10204 unsigned char arg2 ;
10205 unsigned char arg3 ;
10206 unsigned long result;
10207 PyObject * obj0 = 0 ;
10208 PyObject * obj1 = 0 ;
10209 PyObject * obj2 = 0 ;
10210 char *kwnames[] = {
10211 (char *) "r",(char *) "g",(char *) "b", NULL
10212 };
10213
10214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10215 {
10216 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10217 if (SWIG_arg_fail(1)) SWIG_fail;
10218 }
10219 {
10220 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10221 if (SWIG_arg_fail(2)) SWIG_fail;
10222 }
10223 {
10224 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10225 if (SWIG_arg_fail(3)) SWIG_fail;
10226 }
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10230
10231 wxPyEndAllowThreads(__tstate);
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 {
10235 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10236 }
10237 return resultobj;
10238 fail:
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj;
10245 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10246 unsigned char *arg2 = (unsigned char *) 0 ;
10247 unsigned char *arg3 = (unsigned char *) 0 ;
10248 unsigned char *arg4 = (unsigned char *) 0 ;
10249 unsigned char arg5 = (unsigned char) 1 ;
10250 unsigned char arg6 = (unsigned char) 0 ;
10251 unsigned char arg7 = (unsigned char) 0 ;
10252 bool result;
10253 unsigned char temp2 ;
10254 int res2 = 0 ;
10255 unsigned char temp3 ;
10256 int res3 = 0 ;
10257 unsigned char temp4 ;
10258 int res4 = 0 ;
10259 PyObject * obj0 = 0 ;
10260 PyObject * obj1 = 0 ;
10261 PyObject * obj2 = 0 ;
10262 PyObject * obj3 = 0 ;
10263 char *kwnames[] = {
10264 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10265 };
10266
10267 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10268 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10269 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10272 if (SWIG_arg_fail(1)) SWIG_fail;
10273 if (obj1) {
10274 {
10275 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10276 if (SWIG_arg_fail(5)) SWIG_fail;
10277 }
10278 }
10279 if (obj2) {
10280 {
10281 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10282 if (SWIG_arg_fail(6)) SWIG_fail;
10283 }
10284 }
10285 if (obj3) {
10286 {
10287 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10288 if (SWIG_arg_fail(7)) SWIG_fail;
10289 }
10290 }
10291 {
10292 PyThreadState* __tstate = wxPyBeginAllowThreads();
10293 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10294
10295 wxPyEndAllowThreads(__tstate);
10296 if (PyErr_Occurred()) SWIG_fail;
10297 }
10298 {
10299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10300 }
10301 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10302 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10303 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10304 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10305 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10306 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10307 return resultobj;
10308 fail:
10309 return NULL;
10310 }
10311
10312
10313 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10314 PyObject *obj;
10315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10316 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10317 Py_INCREF(obj);
10318 return Py_BuildValue((char *)"");
10319 }
10320 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10321 PyObject *resultobj;
10322 wxString *arg1 = 0 ;
10323 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10324 int arg3 = (int) -1 ;
10325 wxImage *result;
10326 bool temp1 = false ;
10327 PyObject * obj0 = 0 ;
10328 PyObject * obj1 = 0 ;
10329 PyObject * obj2 = 0 ;
10330 char *kwnames[] = {
10331 (char *) "name",(char *) "type",(char *) "index", NULL
10332 };
10333
10334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10335 {
10336 arg1 = wxString_in_helper(obj0);
10337 if (arg1 == NULL) SWIG_fail;
10338 temp1 = true;
10339 }
10340 if (obj1) {
10341 {
10342 arg2 = (long)(SWIG_As_long(obj1));
10343 if (SWIG_arg_fail(2)) SWIG_fail;
10344 }
10345 }
10346 if (obj2) {
10347 {
10348 arg3 = (int)(SWIG_As_int(obj2));
10349 if (SWIG_arg_fail(3)) SWIG_fail;
10350 }
10351 }
10352 {
10353 PyThreadState* __tstate = wxPyBeginAllowThreads();
10354 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10355
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10360 {
10361 if (temp1)
10362 delete arg1;
10363 }
10364 return resultobj;
10365 fail:
10366 {
10367 if (temp1)
10368 delete arg1;
10369 }
10370 return NULL;
10371 }
10372
10373
10374 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10375 PyObject *resultobj;
10376 wxImage *arg1 = (wxImage *) 0 ;
10377 PyObject * obj0 = 0 ;
10378 char *kwnames[] = {
10379 (char *) "self", NULL
10380 };
10381
10382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10384 if (SWIG_arg_fail(1)) SWIG_fail;
10385 {
10386 PyThreadState* __tstate = wxPyBeginAllowThreads();
10387 delete arg1;
10388
10389 wxPyEndAllowThreads(__tstate);
10390 if (PyErr_Occurred()) SWIG_fail;
10391 }
10392 Py_INCREF(Py_None); resultobj = Py_None;
10393 return resultobj;
10394 fail:
10395 return NULL;
10396 }
10397
10398
10399 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10400 PyObject *resultobj;
10401 wxString *arg1 = 0 ;
10402 wxString *arg2 = 0 ;
10403 int arg3 = (int) -1 ;
10404 wxImage *result;
10405 bool temp1 = false ;
10406 bool temp2 = false ;
10407 PyObject * obj0 = 0 ;
10408 PyObject * obj1 = 0 ;
10409 PyObject * obj2 = 0 ;
10410 char *kwnames[] = {
10411 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10412 };
10413
10414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10415 {
10416 arg1 = wxString_in_helper(obj0);
10417 if (arg1 == NULL) SWIG_fail;
10418 temp1 = true;
10419 }
10420 {
10421 arg2 = wxString_in_helper(obj1);
10422 if (arg2 == NULL) SWIG_fail;
10423 temp2 = true;
10424 }
10425 if (obj2) {
10426 {
10427 arg3 = (int)(SWIG_As_int(obj2));
10428 if (SWIG_arg_fail(3)) SWIG_fail;
10429 }
10430 }
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10434
10435 wxPyEndAllowThreads(__tstate);
10436 if (PyErr_Occurred()) SWIG_fail;
10437 }
10438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10439 {
10440 if (temp1)
10441 delete arg1;
10442 }
10443 {
10444 if (temp2)
10445 delete arg2;
10446 }
10447 return resultobj;
10448 fail:
10449 {
10450 if (temp1)
10451 delete arg1;
10452 }
10453 {
10454 if (temp2)
10455 delete arg2;
10456 }
10457 return NULL;
10458 }
10459
10460
10461 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10462 PyObject *resultobj;
10463 wxInputStream *arg1 = 0 ;
10464 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10465 int arg3 = (int) -1 ;
10466 wxImage *result;
10467 wxPyInputStream *temp1 ;
10468 bool created1 ;
10469 PyObject * obj0 = 0 ;
10470 PyObject * obj1 = 0 ;
10471 PyObject * obj2 = 0 ;
10472 char *kwnames[] = {
10473 (char *) "stream",(char *) "type",(char *) "index", NULL
10474 };
10475
10476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10477 {
10478 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10479 arg1 = temp1->m_wxis;
10480 created1 = false;
10481 } else {
10482 PyErr_Clear(); // clear the failure of the wxPyConvert above
10483 arg1 = wxPyCBInputStream_create(obj0, false);
10484 if (arg1 == NULL) {
10485 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10486 SWIG_fail;
10487 }
10488 created1 = true;
10489 }
10490 }
10491 if (obj1) {
10492 {
10493 arg2 = (long)(SWIG_As_long(obj1));
10494 if (SWIG_arg_fail(2)) SWIG_fail;
10495 }
10496 }
10497 if (obj2) {
10498 {
10499 arg3 = (int)(SWIG_As_int(obj2));
10500 if (SWIG_arg_fail(3)) SWIG_fail;
10501 }
10502 }
10503 {
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10506
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10511 {
10512 if (created1)
10513 delete arg1;
10514 }
10515 return resultobj;
10516 fail:
10517 {
10518 if (created1)
10519 delete arg1;
10520 }
10521 return NULL;
10522 }
10523
10524
10525 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10526 PyObject *resultobj;
10527 wxInputStream *arg1 = 0 ;
10528 wxString *arg2 = 0 ;
10529 int arg3 = (int) -1 ;
10530 wxImage *result;
10531 wxPyInputStream *temp1 ;
10532 bool created1 ;
10533 bool temp2 = false ;
10534 PyObject * obj0 = 0 ;
10535 PyObject * obj1 = 0 ;
10536 PyObject * obj2 = 0 ;
10537 char *kwnames[] = {
10538 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10539 };
10540
10541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10542 {
10543 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10544 arg1 = temp1->m_wxis;
10545 created1 = false;
10546 } else {
10547 PyErr_Clear(); // clear the failure of the wxPyConvert above
10548 arg1 = wxPyCBInputStream_create(obj0, false);
10549 if (arg1 == NULL) {
10550 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10551 SWIG_fail;
10552 }
10553 created1 = true;
10554 }
10555 }
10556 {
10557 arg2 = wxString_in_helper(obj1);
10558 if (arg2 == NULL) SWIG_fail;
10559 temp2 = true;
10560 }
10561 if (obj2) {
10562 {
10563 arg3 = (int)(SWIG_As_int(obj2));
10564 if (SWIG_arg_fail(3)) SWIG_fail;
10565 }
10566 }
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10570
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10575 {
10576 if (created1)
10577 delete arg1;
10578 }
10579 {
10580 if (temp2)
10581 delete arg2;
10582 }
10583 return resultobj;
10584 fail:
10585 {
10586 if (created1)
10587 delete arg1;
10588 }
10589 {
10590 if (temp2)
10591 delete arg2;
10592 }
10593 return NULL;
10594 }
10595
10596
10597 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10598 PyObject *resultobj;
10599 int arg1 = (int) 0 ;
10600 int arg2 = (int) 0 ;
10601 bool arg3 = (bool) true ;
10602 wxImage *result;
10603 PyObject * obj0 = 0 ;
10604 PyObject * obj1 = 0 ;
10605 PyObject * obj2 = 0 ;
10606 char *kwnames[] = {
10607 (char *) "width",(char *) "height",(char *) "clear", NULL
10608 };
10609
10610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10611 if (obj0) {
10612 {
10613 arg1 = (int)(SWIG_As_int(obj0));
10614 if (SWIG_arg_fail(1)) SWIG_fail;
10615 }
10616 }
10617 if (obj1) {
10618 {
10619 arg2 = (int)(SWIG_As_int(obj1));
10620 if (SWIG_arg_fail(2)) SWIG_fail;
10621 }
10622 }
10623 if (obj2) {
10624 {
10625 arg3 = (bool)(SWIG_As_bool(obj2));
10626 if (SWIG_arg_fail(3)) SWIG_fail;
10627 }
10628 }
10629 {
10630 PyThreadState* __tstate = wxPyBeginAllowThreads();
10631 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10632
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10637 return resultobj;
10638 fail:
10639 return NULL;
10640 }
10641
10642
10643 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10644 PyObject *resultobj;
10645 wxBitmap *arg1 = 0 ;
10646 wxImage *result;
10647 PyObject * obj0 = 0 ;
10648 char *kwnames[] = {
10649 (char *) "bitmap", NULL
10650 };
10651
10652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10653 {
10654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10655 if (SWIG_arg_fail(1)) SWIG_fail;
10656 if (arg1 == NULL) {
10657 SWIG_null_ref("wxBitmap");
10658 }
10659 if (SWIG_arg_fail(1)) SWIG_fail;
10660 }
10661 {
10662 if (!wxPyCheckForApp()) SWIG_fail;
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10665
10666 wxPyEndAllowThreads(__tstate);
10667 if (PyErr_Occurred()) SWIG_fail;
10668 }
10669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10670 return resultobj;
10671 fail:
10672 return NULL;
10673 }
10674
10675
10676 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10677 PyObject *resultobj;
10678 int arg1 ;
10679 int arg2 ;
10680 unsigned char *arg3 = (unsigned char *) 0 ;
10681 wxImage *result;
10682 PyObject * obj0 = 0 ;
10683 PyObject * obj1 = 0 ;
10684 PyObject * obj2 = 0 ;
10685 char *kwnames[] = {
10686 (char *) "width",(char *) "height",(char *) "data", NULL
10687 };
10688
10689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10690 {
10691 arg1 = (int)(SWIG_As_int(obj0));
10692 if (SWIG_arg_fail(1)) SWIG_fail;
10693 }
10694 {
10695 arg2 = (int)(SWIG_As_int(obj1));
10696 if (SWIG_arg_fail(2)) SWIG_fail;
10697 }
10698 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10699 if (SWIG_arg_fail(3)) SWIG_fail;
10700 {
10701 PyThreadState* __tstate = wxPyBeginAllowThreads();
10702 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10703
10704 wxPyEndAllowThreads(__tstate);
10705 if (PyErr_Occurred()) SWIG_fail;
10706 }
10707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10708 return resultobj;
10709 fail:
10710 return NULL;
10711 }
10712
10713
10714 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10715 PyObject *resultobj;
10716 int arg1 ;
10717 int arg2 ;
10718 unsigned char *arg3 = (unsigned char *) 0 ;
10719 unsigned char *arg4 = (unsigned char *) 0 ;
10720 wxImage *result;
10721 PyObject * obj0 = 0 ;
10722 PyObject * obj1 = 0 ;
10723 PyObject * obj2 = 0 ;
10724 PyObject * obj3 = 0 ;
10725 char *kwnames[] = {
10726 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10727 };
10728
10729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10730 {
10731 arg1 = (int)(SWIG_As_int(obj0));
10732 if (SWIG_arg_fail(1)) SWIG_fail;
10733 }
10734 {
10735 arg2 = (int)(SWIG_As_int(obj1));
10736 if (SWIG_arg_fail(2)) SWIG_fail;
10737 }
10738 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10739 if (SWIG_arg_fail(3)) SWIG_fail;
10740 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10741 if (SWIG_arg_fail(4)) SWIG_fail;
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10745
10746 wxPyEndAllowThreads(__tstate);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10750 return resultobj;
10751 fail:
10752 return NULL;
10753 }
10754
10755
10756 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10757 PyObject *resultobj;
10758 wxImage *arg1 = (wxImage *) 0 ;
10759 int arg2 ;
10760 int arg3 ;
10761 PyObject * obj0 = 0 ;
10762 PyObject * obj1 = 0 ;
10763 PyObject * obj2 = 0 ;
10764 char *kwnames[] = {
10765 (char *) "self",(char *) "width",(char *) "height", NULL
10766 };
10767
10768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10770 if (SWIG_arg_fail(1)) SWIG_fail;
10771 {
10772 arg2 = (int)(SWIG_As_int(obj1));
10773 if (SWIG_arg_fail(2)) SWIG_fail;
10774 }
10775 {
10776 arg3 = (int)(SWIG_As_int(obj2));
10777 if (SWIG_arg_fail(3)) SWIG_fail;
10778 }
10779 {
10780 PyThreadState* __tstate = wxPyBeginAllowThreads();
10781 (arg1)->Create(arg2,arg3);
10782
10783 wxPyEndAllowThreads(__tstate);
10784 if (PyErr_Occurred()) SWIG_fail;
10785 }
10786 Py_INCREF(Py_None); resultobj = Py_None;
10787 return resultobj;
10788 fail:
10789 return NULL;
10790 }
10791
10792
10793 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10794 PyObject *resultobj;
10795 wxImage *arg1 = (wxImage *) 0 ;
10796 PyObject * obj0 = 0 ;
10797 char *kwnames[] = {
10798 (char *) "self", NULL
10799 };
10800
10801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10803 if (SWIG_arg_fail(1)) SWIG_fail;
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 (arg1)->Destroy();
10807
10808 wxPyEndAllowThreads(__tstate);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 Py_INCREF(Py_None); resultobj = Py_None;
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj;
10820 wxImage *arg1 = (wxImage *) 0 ;
10821 int arg2 ;
10822 int arg3 ;
10823 SwigValueWrapper<wxImage > result;
10824 PyObject * obj0 = 0 ;
10825 PyObject * obj1 = 0 ;
10826 PyObject * obj2 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "self",(char *) "width",(char *) "height", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10833 if (SWIG_arg_fail(1)) SWIG_fail;
10834 {
10835 arg2 = (int)(SWIG_As_int(obj1));
10836 if (SWIG_arg_fail(2)) SWIG_fail;
10837 }
10838 {
10839 arg3 = (int)(SWIG_As_int(obj2));
10840 if (SWIG_arg_fail(3)) SWIG_fail;
10841 }
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (arg1)->Scale(arg2,arg3);
10845
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 {
10850 wxImage * resultptr;
10851 resultptr = new wxImage((wxImage &)(result));
10852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10853 }
10854 return resultobj;
10855 fail:
10856 return NULL;
10857 }
10858
10859
10860 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10861 PyObject *resultobj;
10862 wxImage *arg1 = (wxImage *) 0 ;
10863 int arg2 ;
10864 int arg3 ;
10865 SwigValueWrapper<wxImage > result;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 PyObject * obj2 = 0 ;
10869 char *kwnames[] = {
10870 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10871 };
10872
10873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10875 if (SWIG_arg_fail(1)) SWIG_fail;
10876 {
10877 arg2 = (int)(SWIG_As_int(obj1));
10878 if (SWIG_arg_fail(2)) SWIG_fail;
10879 }
10880 {
10881 arg3 = (int)(SWIG_As_int(obj2));
10882 if (SWIG_arg_fail(3)) SWIG_fail;
10883 }
10884 {
10885 PyThreadState* __tstate = wxPyBeginAllowThreads();
10886 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10887
10888 wxPyEndAllowThreads(__tstate);
10889 if (PyErr_Occurred()) SWIG_fail;
10890 }
10891 {
10892 wxImage * resultptr;
10893 resultptr = new wxImage((wxImage &)(result));
10894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10895 }
10896 return resultobj;
10897 fail:
10898 return NULL;
10899 }
10900
10901
10902 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj;
10904 wxImage *arg1 = (wxImage *) 0 ;
10905 int arg2 ;
10906 int arg3 ;
10907 wxImage *result;
10908 PyObject * obj0 = 0 ;
10909 PyObject * obj1 = 0 ;
10910 PyObject * obj2 = 0 ;
10911 char *kwnames[] = {
10912 (char *) "self",(char *) "width",(char *) "height", NULL
10913 };
10914
10915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10917 if (SWIG_arg_fail(1)) SWIG_fail;
10918 {
10919 arg2 = (int)(SWIG_As_int(obj1));
10920 if (SWIG_arg_fail(2)) SWIG_fail;
10921 }
10922 {
10923 arg3 = (int)(SWIG_As_int(obj2));
10924 if (SWIG_arg_fail(3)) SWIG_fail;
10925 }
10926 {
10927 PyThreadState* __tstate = wxPyBeginAllowThreads();
10928 {
10929 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10930 result = (wxImage *) &_result_ref;
10931 }
10932
10933 wxPyEndAllowThreads(__tstate);
10934 if (PyErr_Occurred()) SWIG_fail;
10935 }
10936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10937 return resultobj;
10938 fail:
10939 return NULL;
10940 }
10941
10942
10943 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10944 PyObject *resultobj;
10945 wxImage *arg1 = (wxImage *) 0 ;
10946 int arg2 ;
10947 int arg3 ;
10948 unsigned char arg4 ;
10949 unsigned char arg5 ;
10950 unsigned char arg6 ;
10951 PyObject * obj0 = 0 ;
10952 PyObject * obj1 = 0 ;
10953 PyObject * obj2 = 0 ;
10954 PyObject * obj3 = 0 ;
10955 PyObject * obj4 = 0 ;
10956 PyObject * obj5 = 0 ;
10957 char *kwnames[] = {
10958 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10959 };
10960
10961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10963 if (SWIG_arg_fail(1)) SWIG_fail;
10964 {
10965 arg2 = (int)(SWIG_As_int(obj1));
10966 if (SWIG_arg_fail(2)) SWIG_fail;
10967 }
10968 {
10969 arg3 = (int)(SWIG_As_int(obj2));
10970 if (SWIG_arg_fail(3)) SWIG_fail;
10971 }
10972 {
10973 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10974 if (SWIG_arg_fail(4)) SWIG_fail;
10975 }
10976 {
10977 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10978 if (SWIG_arg_fail(5)) SWIG_fail;
10979 }
10980 {
10981 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10982 if (SWIG_arg_fail(6)) SWIG_fail;
10983 }
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10987
10988 wxPyEndAllowThreads(__tstate);
10989 if (PyErr_Occurred()) SWIG_fail;
10990 }
10991 Py_INCREF(Py_None); resultobj = Py_None;
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj;
11000 wxImage *arg1 = (wxImage *) 0 ;
11001 int arg2 ;
11002 int arg3 ;
11003 unsigned char result;
11004 PyObject * obj0 = 0 ;
11005 PyObject * obj1 = 0 ;
11006 PyObject * obj2 = 0 ;
11007 char *kwnames[] = {
11008 (char *) "self",(char *) "x",(char *) "y", NULL
11009 };
11010
11011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11013 if (SWIG_arg_fail(1)) SWIG_fail;
11014 {
11015 arg2 = (int)(SWIG_As_int(obj1));
11016 if (SWIG_arg_fail(2)) SWIG_fail;
11017 }
11018 {
11019 arg3 = (int)(SWIG_As_int(obj2));
11020 if (SWIG_arg_fail(3)) SWIG_fail;
11021 }
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11025
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 {
11030 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11031 }
11032 return resultobj;
11033 fail:
11034 return NULL;
11035 }
11036
11037
11038 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11039 PyObject *resultobj;
11040 wxImage *arg1 = (wxImage *) 0 ;
11041 int arg2 ;
11042 int arg3 ;
11043 unsigned char result;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046 PyObject * obj2 = 0 ;
11047 char *kwnames[] = {
11048 (char *) "self",(char *) "x",(char *) "y", NULL
11049 };
11050
11051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11053 if (SWIG_arg_fail(1)) SWIG_fail;
11054 {
11055 arg2 = (int)(SWIG_As_int(obj1));
11056 if (SWIG_arg_fail(2)) SWIG_fail;
11057 }
11058 {
11059 arg3 = (int)(SWIG_As_int(obj2));
11060 if (SWIG_arg_fail(3)) SWIG_fail;
11061 }
11062 {
11063 PyThreadState* __tstate = wxPyBeginAllowThreads();
11064 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11065
11066 wxPyEndAllowThreads(__tstate);
11067 if (PyErr_Occurred()) SWIG_fail;
11068 }
11069 {
11070 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11071 }
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11079 PyObject *resultobj;
11080 wxImage *arg1 = (wxImage *) 0 ;
11081 int arg2 ;
11082 int arg3 ;
11083 unsigned char result;
11084 PyObject * obj0 = 0 ;
11085 PyObject * obj1 = 0 ;
11086 PyObject * obj2 = 0 ;
11087 char *kwnames[] = {
11088 (char *) "self",(char *) "x",(char *) "y", NULL
11089 };
11090
11091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11093 if (SWIG_arg_fail(1)) SWIG_fail;
11094 {
11095 arg2 = (int)(SWIG_As_int(obj1));
11096 if (SWIG_arg_fail(2)) SWIG_fail;
11097 }
11098 {
11099 arg3 = (int)(SWIG_As_int(obj2));
11100 if (SWIG_arg_fail(3)) SWIG_fail;
11101 }
11102 {
11103 PyThreadState* __tstate = wxPyBeginAllowThreads();
11104 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11105
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 {
11110 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11111 }
11112 return resultobj;
11113 fail:
11114 return NULL;
11115 }
11116
11117
11118 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11119 PyObject *resultobj;
11120 wxImage *arg1 = (wxImage *) 0 ;
11121 int arg2 ;
11122 int arg3 ;
11123 unsigned char arg4 ;
11124 PyObject * obj0 = 0 ;
11125 PyObject * obj1 = 0 ;
11126 PyObject * obj2 = 0 ;
11127 PyObject * obj3 = 0 ;
11128 char *kwnames[] = {
11129 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11130 };
11131
11132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11134 if (SWIG_arg_fail(1)) SWIG_fail;
11135 {
11136 arg2 = (int)(SWIG_As_int(obj1));
11137 if (SWIG_arg_fail(2)) SWIG_fail;
11138 }
11139 {
11140 arg3 = (int)(SWIG_As_int(obj2));
11141 if (SWIG_arg_fail(3)) SWIG_fail;
11142 }
11143 {
11144 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11145 if (SWIG_arg_fail(4)) SWIG_fail;
11146 }
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 (arg1)->SetAlpha(arg2,arg3,arg4);
11150
11151 wxPyEndAllowThreads(__tstate);
11152 if (PyErr_Occurred()) SWIG_fail;
11153 }
11154 Py_INCREF(Py_None); resultobj = Py_None;
11155 return resultobj;
11156 fail:
11157 return NULL;
11158 }
11159
11160
11161 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11162 PyObject *resultobj;
11163 wxImage *arg1 = (wxImage *) 0 ;
11164 int arg2 ;
11165 int arg3 ;
11166 unsigned char result;
11167 PyObject * obj0 = 0 ;
11168 PyObject * obj1 = 0 ;
11169 PyObject * obj2 = 0 ;
11170 char *kwnames[] = {
11171 (char *) "self",(char *) "x",(char *) "y", NULL
11172 };
11173
11174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11176 if (SWIG_arg_fail(1)) SWIG_fail;
11177 {
11178 arg2 = (int)(SWIG_As_int(obj1));
11179 if (SWIG_arg_fail(2)) SWIG_fail;
11180 }
11181 {
11182 arg3 = (int)(SWIG_As_int(obj2));
11183 if (SWIG_arg_fail(3)) SWIG_fail;
11184 }
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11188
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 {
11193 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11194 }
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj;
11203 wxImage *arg1 = (wxImage *) 0 ;
11204 bool result;
11205 PyObject * obj0 = 0 ;
11206 char *kwnames[] = {
11207 (char *) "self", NULL
11208 };
11209
11210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11212 if (SWIG_arg_fail(1)) SWIG_fail;
11213 {
11214 PyThreadState* __tstate = wxPyBeginAllowThreads();
11215 result = (bool)(arg1)->HasAlpha();
11216
11217 wxPyEndAllowThreads(__tstate);
11218 if (PyErr_Occurred()) SWIG_fail;
11219 }
11220 {
11221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11222 }
11223 return resultobj;
11224 fail:
11225 return NULL;
11226 }
11227
11228
11229 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11230 PyObject *resultobj;
11231 wxImage *arg1 = (wxImage *) 0 ;
11232 PyObject * obj0 = 0 ;
11233 char *kwnames[] = {
11234 (char *) "self", NULL
11235 };
11236
11237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11239 if (SWIG_arg_fail(1)) SWIG_fail;
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 (arg1)->InitAlpha();
11243
11244 wxPyEndAllowThreads(__tstate);
11245 if (PyErr_Occurred()) SWIG_fail;
11246 }
11247 Py_INCREF(Py_None); resultobj = Py_None;
11248 return resultobj;
11249 fail:
11250 return NULL;
11251 }
11252
11253
11254 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11255 PyObject *resultobj;
11256 wxImage *arg1 = (wxImage *) 0 ;
11257 byte *arg2 = (byte *) 0 ;
11258 byte *arg3 = (byte *) 0 ;
11259 byte *arg4 = (byte *) 0 ;
11260 byte arg5 = (byte) 0 ;
11261 byte arg6 = (byte) 0 ;
11262 byte arg7 = (byte) 0 ;
11263 bool result;
11264 byte temp2 ;
11265 int res2 = 0 ;
11266 byte temp3 ;
11267 int res3 = 0 ;
11268 byte temp4 ;
11269 int res4 = 0 ;
11270 PyObject * obj0 = 0 ;
11271 PyObject * obj1 = 0 ;
11272 PyObject * obj2 = 0 ;
11273 PyObject * obj3 = 0 ;
11274 char *kwnames[] = {
11275 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11276 };
11277
11278 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11279 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11280 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11283 if (SWIG_arg_fail(1)) SWIG_fail;
11284 if (obj1) {
11285 {
11286 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11287 if (SWIG_arg_fail(5)) SWIG_fail;
11288 }
11289 }
11290 if (obj2) {
11291 {
11292 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11293 if (SWIG_arg_fail(6)) SWIG_fail;
11294 }
11295 }
11296 if (obj3) {
11297 {
11298 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11299 if (SWIG_arg_fail(7)) SWIG_fail;
11300 }
11301 }
11302 {
11303 PyThreadState* __tstate = wxPyBeginAllowThreads();
11304 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11305
11306 wxPyEndAllowThreads(__tstate);
11307 if (PyErr_Occurred()) SWIG_fail;
11308 }
11309 {
11310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11311 }
11312 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11313 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11314 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11315 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11316 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11317 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11318 return resultobj;
11319 fail:
11320 return NULL;
11321 }
11322
11323
11324 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11325 PyObject *resultobj;
11326 wxImage *arg1 = (wxImage *) 0 ;
11327 byte arg2 = (byte) 128 ;
11328 bool result;
11329 PyObject * obj0 = 0 ;
11330 PyObject * obj1 = 0 ;
11331 char *kwnames[] = {
11332 (char *) "self",(char *) "threshold", NULL
11333 };
11334
11335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11337 if (SWIG_arg_fail(1)) SWIG_fail;
11338 if (obj1) {
11339 {
11340 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11341 if (SWIG_arg_fail(2)) SWIG_fail;
11342 }
11343 }
11344 {
11345 PyThreadState* __tstate = wxPyBeginAllowThreads();
11346 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11347
11348 wxPyEndAllowThreads(__tstate);
11349 if (PyErr_Occurred()) SWIG_fail;
11350 }
11351 {
11352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11353 }
11354 return resultobj;
11355 fail:
11356 return NULL;
11357 }
11358
11359
11360 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11361 PyObject *resultobj;
11362 wxImage *arg1 = (wxImage *) 0 ;
11363 unsigned char arg2 ;
11364 unsigned char arg3 ;
11365 unsigned char arg4 ;
11366 bool result;
11367 PyObject * obj0 = 0 ;
11368 PyObject * obj1 = 0 ;
11369 PyObject * obj2 = 0 ;
11370 PyObject * obj3 = 0 ;
11371 char *kwnames[] = {
11372 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11373 };
11374
11375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11377 if (SWIG_arg_fail(1)) SWIG_fail;
11378 {
11379 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11380 if (SWIG_arg_fail(2)) SWIG_fail;
11381 }
11382 {
11383 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11384 if (SWIG_arg_fail(3)) SWIG_fail;
11385 }
11386 {
11387 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11388 if (SWIG_arg_fail(4)) SWIG_fail;
11389 }
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11393
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 {
11398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11399 }
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11407 PyObject *resultobj;
11408 wxImage *arg1 = (wxImage *) 0 ;
11409 wxImage *arg2 = 0 ;
11410 byte arg3 ;
11411 byte arg4 ;
11412 byte arg5 ;
11413 bool result;
11414 PyObject * obj0 = 0 ;
11415 PyObject * obj1 = 0 ;
11416 PyObject * obj2 = 0 ;
11417 PyObject * obj3 = 0 ;
11418 PyObject * obj4 = 0 ;
11419 char *kwnames[] = {
11420 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11421 };
11422
11423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11425 if (SWIG_arg_fail(1)) SWIG_fail;
11426 {
11427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11428 if (SWIG_arg_fail(2)) SWIG_fail;
11429 if (arg2 == NULL) {
11430 SWIG_null_ref("wxImage");
11431 }
11432 if (SWIG_arg_fail(2)) SWIG_fail;
11433 }
11434 {
11435 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11436 if (SWIG_arg_fail(3)) SWIG_fail;
11437 }
11438 {
11439 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11440 if (SWIG_arg_fail(4)) SWIG_fail;
11441 }
11442 {
11443 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11444 if (SWIG_arg_fail(5)) SWIG_fail;
11445 }
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11449
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 {
11454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11455 }
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj;
11464 wxString *arg1 = 0 ;
11465 bool result;
11466 bool temp1 = false ;
11467 PyObject * obj0 = 0 ;
11468 char *kwnames[] = {
11469 (char *) "name", NULL
11470 };
11471
11472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11473 {
11474 arg1 = wxString_in_helper(obj0);
11475 if (arg1 == NULL) SWIG_fail;
11476 temp1 = true;
11477 }
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11481
11482 wxPyEndAllowThreads(__tstate);
11483 if (PyErr_Occurred()) SWIG_fail;
11484 }
11485 {
11486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11487 }
11488 {
11489 if (temp1)
11490 delete arg1;
11491 }
11492 return resultobj;
11493 fail:
11494 {
11495 if (temp1)
11496 delete arg1;
11497 }
11498 return NULL;
11499 }
11500
11501
11502 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11503 PyObject *resultobj;
11504 wxString *arg1 = 0 ;
11505 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11506 int result;
11507 bool temp1 = false ;
11508 PyObject * obj0 = 0 ;
11509 PyObject * obj1 = 0 ;
11510 char *kwnames[] = {
11511 (char *) "name",(char *) "type", NULL
11512 };
11513
11514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11515 {
11516 arg1 = wxString_in_helper(obj0);
11517 if (arg1 == NULL) SWIG_fail;
11518 temp1 = true;
11519 }
11520 if (obj1) {
11521 {
11522 arg2 = (long)(SWIG_As_long(obj1));
11523 if (SWIG_arg_fail(2)) SWIG_fail;
11524 }
11525 }
11526 {
11527 PyThreadState* __tstate = wxPyBeginAllowThreads();
11528 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11529
11530 wxPyEndAllowThreads(__tstate);
11531 if (PyErr_Occurred()) SWIG_fail;
11532 }
11533 {
11534 resultobj = SWIG_From_int((int)(result));
11535 }
11536 {
11537 if (temp1)
11538 delete arg1;
11539 }
11540 return resultobj;
11541 fail:
11542 {
11543 if (temp1)
11544 delete arg1;
11545 }
11546 return NULL;
11547 }
11548
11549
11550 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj;
11552 wxImage *arg1 = (wxImage *) 0 ;
11553 wxString *arg2 = 0 ;
11554 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11555 int arg4 = (int) -1 ;
11556 bool result;
11557 bool temp2 = false ;
11558 PyObject * obj0 = 0 ;
11559 PyObject * obj1 = 0 ;
11560 PyObject * obj2 = 0 ;
11561 PyObject * obj3 = 0 ;
11562 char *kwnames[] = {
11563 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11564 };
11565
11566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11568 if (SWIG_arg_fail(1)) SWIG_fail;
11569 {
11570 arg2 = wxString_in_helper(obj1);
11571 if (arg2 == NULL) SWIG_fail;
11572 temp2 = true;
11573 }
11574 if (obj2) {
11575 {
11576 arg3 = (long)(SWIG_As_long(obj2));
11577 if (SWIG_arg_fail(3)) SWIG_fail;
11578 }
11579 }
11580 if (obj3) {
11581 {
11582 arg4 = (int)(SWIG_As_int(obj3));
11583 if (SWIG_arg_fail(4)) SWIG_fail;
11584 }
11585 }
11586 {
11587 PyThreadState* __tstate = wxPyBeginAllowThreads();
11588 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11589
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 {
11594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11595 }
11596 {
11597 if (temp2)
11598 delete arg2;
11599 }
11600 return resultobj;
11601 fail:
11602 {
11603 if (temp2)
11604 delete arg2;
11605 }
11606 return NULL;
11607 }
11608
11609
11610 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11611 PyObject *resultobj;
11612 wxImage *arg1 = (wxImage *) 0 ;
11613 wxString *arg2 = 0 ;
11614 wxString *arg3 = 0 ;
11615 int arg4 = (int) -1 ;
11616 bool result;
11617 bool temp2 = false ;
11618 bool temp3 = false ;
11619 PyObject * obj0 = 0 ;
11620 PyObject * obj1 = 0 ;
11621 PyObject * obj2 = 0 ;
11622 PyObject * obj3 = 0 ;
11623 char *kwnames[] = {
11624 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11625 };
11626
11627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11629 if (SWIG_arg_fail(1)) SWIG_fail;
11630 {
11631 arg2 = wxString_in_helper(obj1);
11632 if (arg2 == NULL) SWIG_fail;
11633 temp2 = true;
11634 }
11635 {
11636 arg3 = wxString_in_helper(obj2);
11637 if (arg3 == NULL) SWIG_fail;
11638 temp3 = true;
11639 }
11640 if (obj3) {
11641 {
11642 arg4 = (int)(SWIG_As_int(obj3));
11643 if (SWIG_arg_fail(4)) SWIG_fail;
11644 }
11645 }
11646 {
11647 PyThreadState* __tstate = wxPyBeginAllowThreads();
11648 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11649
11650 wxPyEndAllowThreads(__tstate);
11651 if (PyErr_Occurred()) SWIG_fail;
11652 }
11653 {
11654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11655 }
11656 {
11657 if (temp2)
11658 delete arg2;
11659 }
11660 {
11661 if (temp3)
11662 delete arg3;
11663 }
11664 return resultobj;
11665 fail:
11666 {
11667 if (temp2)
11668 delete arg2;
11669 }
11670 {
11671 if (temp3)
11672 delete arg3;
11673 }
11674 return NULL;
11675 }
11676
11677
11678 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj;
11680 wxImage *arg1 = (wxImage *) 0 ;
11681 wxString *arg2 = 0 ;
11682 int arg3 ;
11683 bool result;
11684 bool temp2 = false ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 char *kwnames[] = {
11689 (char *) "self",(char *) "name",(char *) "type", NULL
11690 };
11691
11692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11694 if (SWIG_arg_fail(1)) SWIG_fail;
11695 {
11696 arg2 = wxString_in_helper(obj1);
11697 if (arg2 == NULL) SWIG_fail;
11698 temp2 = true;
11699 }
11700 {
11701 arg3 = (int)(SWIG_As_int(obj2));
11702 if (SWIG_arg_fail(3)) SWIG_fail;
11703 }
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
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_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj;
11730 wxImage *arg1 = (wxImage *) 0 ;
11731 wxString *arg2 = 0 ;
11732 wxString *arg3 = 0 ;
11733 bool result;
11734 bool temp2 = false ;
11735 bool temp3 = false ;
11736 PyObject * obj0 = 0 ;
11737 PyObject * obj1 = 0 ;
11738 PyObject * obj2 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11745 if (SWIG_arg_fail(1)) SWIG_fail;
11746 {
11747 arg2 = wxString_in_helper(obj1);
11748 if (arg2 == NULL) SWIG_fail;
11749 temp2 = true;
11750 }
11751 {
11752 arg3 = wxString_in_helper(obj2);
11753 if (arg3 == NULL) SWIG_fail;
11754 temp3 = true;
11755 }
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11759
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 {
11764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11765 }
11766 {
11767 if (temp2)
11768 delete arg2;
11769 }
11770 {
11771 if (temp3)
11772 delete arg3;
11773 }
11774 return resultobj;
11775 fail:
11776 {
11777 if (temp2)
11778 delete arg2;
11779 }
11780 {
11781 if (temp3)
11782 delete arg3;
11783 }
11784 return NULL;
11785 }
11786
11787
11788 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11789 PyObject *resultobj;
11790 wxInputStream *arg1 = 0 ;
11791 bool result;
11792 wxPyInputStream *temp1 ;
11793 bool created1 ;
11794 PyObject * obj0 = 0 ;
11795 char *kwnames[] = {
11796 (char *) "stream", NULL
11797 };
11798
11799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11800 {
11801 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11802 arg1 = temp1->m_wxis;
11803 created1 = false;
11804 } else {
11805 PyErr_Clear(); // clear the failure of the wxPyConvert above
11806 arg1 = wxPyCBInputStream_create(obj0, false);
11807 if (arg1 == NULL) {
11808 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11809 SWIG_fail;
11810 }
11811 created1 = true;
11812 }
11813 }
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (bool)wxImage::CanRead(*arg1);
11817
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 {
11822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11823 }
11824 {
11825 if (created1)
11826 delete arg1;
11827 }
11828 return resultobj;
11829 fail:
11830 {
11831 if (created1)
11832 delete arg1;
11833 }
11834 return NULL;
11835 }
11836
11837
11838 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj;
11840 wxImage *arg1 = (wxImage *) 0 ;
11841 wxInputStream *arg2 = 0 ;
11842 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11843 int arg4 = (int) -1 ;
11844 bool result;
11845 wxPyInputStream *temp2 ;
11846 bool created2 ;
11847 PyObject * obj0 = 0 ;
11848 PyObject * obj1 = 0 ;
11849 PyObject * obj2 = 0 ;
11850 PyObject * obj3 = 0 ;
11851 char *kwnames[] = {
11852 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11853 };
11854
11855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11857 if (SWIG_arg_fail(1)) SWIG_fail;
11858 {
11859 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11860 arg2 = temp2->m_wxis;
11861 created2 = false;
11862 } else {
11863 PyErr_Clear(); // clear the failure of the wxPyConvert above
11864 arg2 = wxPyCBInputStream_create(obj1, false);
11865 if (arg2 == NULL) {
11866 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11867 SWIG_fail;
11868 }
11869 created2 = true;
11870 }
11871 }
11872 if (obj2) {
11873 {
11874 arg3 = (long)(SWIG_As_long(obj2));
11875 if (SWIG_arg_fail(3)) SWIG_fail;
11876 }
11877 }
11878 if (obj3) {
11879 {
11880 arg4 = (int)(SWIG_As_int(obj3));
11881 if (SWIG_arg_fail(4)) SWIG_fail;
11882 }
11883 }
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11887
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 {
11892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11893 }
11894 {
11895 if (created2)
11896 delete arg2;
11897 }
11898 return resultobj;
11899 fail:
11900 {
11901 if (created2)
11902 delete arg2;
11903 }
11904 return NULL;
11905 }
11906
11907
11908 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11909 PyObject *resultobj;
11910 wxImage *arg1 = (wxImage *) 0 ;
11911 wxInputStream *arg2 = 0 ;
11912 wxString *arg3 = 0 ;
11913 int arg4 = (int) -1 ;
11914 bool result;
11915 wxPyInputStream *temp2 ;
11916 bool created2 ;
11917 bool temp3 = false ;
11918 PyObject * obj0 = 0 ;
11919 PyObject * obj1 = 0 ;
11920 PyObject * obj2 = 0 ;
11921 PyObject * obj3 = 0 ;
11922 char *kwnames[] = {
11923 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11924 };
11925
11926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11928 if (SWIG_arg_fail(1)) SWIG_fail;
11929 {
11930 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11931 arg2 = temp2->m_wxis;
11932 created2 = false;
11933 } else {
11934 PyErr_Clear(); // clear the failure of the wxPyConvert above
11935 arg2 = wxPyCBInputStream_create(obj1, false);
11936 if (arg2 == NULL) {
11937 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11938 SWIG_fail;
11939 }
11940 created2 = true;
11941 }
11942 }
11943 {
11944 arg3 = wxString_in_helper(obj2);
11945 if (arg3 == NULL) SWIG_fail;
11946 temp3 = true;
11947 }
11948 if (obj3) {
11949 {
11950 arg4 = (int)(SWIG_As_int(obj3));
11951 if (SWIG_arg_fail(4)) SWIG_fail;
11952 }
11953 }
11954 {
11955 PyThreadState* __tstate = wxPyBeginAllowThreads();
11956 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11957
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 {
11962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11963 }
11964 {
11965 if (created2)
11966 delete arg2;
11967 }
11968 {
11969 if (temp3)
11970 delete arg3;
11971 }
11972 return resultobj;
11973 fail:
11974 {
11975 if (created2)
11976 delete arg2;
11977 }
11978 {
11979 if (temp3)
11980 delete arg3;
11981 }
11982 return NULL;
11983 }
11984
11985
11986 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11987 PyObject *resultobj;
11988 wxImage *arg1 = (wxImage *) 0 ;
11989 bool result;
11990 PyObject * obj0 = 0 ;
11991 char *kwnames[] = {
11992 (char *) "self", NULL
11993 };
11994
11995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11997 if (SWIG_arg_fail(1)) SWIG_fail;
11998 {
11999 PyThreadState* __tstate = wxPyBeginAllowThreads();
12000 result = (bool)(arg1)->Ok();
12001
12002 wxPyEndAllowThreads(__tstate);
12003 if (PyErr_Occurred()) SWIG_fail;
12004 }
12005 {
12006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12007 }
12008 return resultobj;
12009 fail:
12010 return NULL;
12011 }
12012
12013
12014 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12015 PyObject *resultobj;
12016 wxImage *arg1 = (wxImage *) 0 ;
12017 int result;
12018 PyObject * obj0 = 0 ;
12019 char *kwnames[] = {
12020 (char *) "self", NULL
12021 };
12022
12023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12025 if (SWIG_arg_fail(1)) SWIG_fail;
12026 {
12027 PyThreadState* __tstate = wxPyBeginAllowThreads();
12028 result = (int)(arg1)->GetWidth();
12029
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 {
12034 resultobj = SWIG_From_int((int)(result));
12035 }
12036 return resultobj;
12037 fail:
12038 return NULL;
12039 }
12040
12041
12042 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12043 PyObject *resultobj;
12044 wxImage *arg1 = (wxImage *) 0 ;
12045 int result;
12046 PyObject * obj0 = 0 ;
12047 char *kwnames[] = {
12048 (char *) "self", NULL
12049 };
12050
12051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12053 if (SWIG_arg_fail(1)) SWIG_fail;
12054 {
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 result = (int)(arg1)->GetHeight();
12057
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 {
12062 resultobj = SWIG_From_int((int)(result));
12063 }
12064 return resultobj;
12065 fail:
12066 return NULL;
12067 }
12068
12069
12070 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12071 PyObject *resultobj;
12072 wxImage *arg1 = (wxImage *) 0 ;
12073 wxSize result;
12074 PyObject * obj0 = 0 ;
12075 char *kwnames[] = {
12076 (char *) "self", NULL
12077 };
12078
12079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12081 if (SWIG_arg_fail(1)) SWIG_fail;
12082 {
12083 PyThreadState* __tstate = wxPyBeginAllowThreads();
12084 result = wxImage_GetSize(arg1);
12085
12086 wxPyEndAllowThreads(__tstate);
12087 if (PyErr_Occurred()) SWIG_fail;
12088 }
12089 {
12090 wxSize * resultptr;
12091 resultptr = new wxSize((wxSize &)(result));
12092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12093 }
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj;
12102 wxImage *arg1 = (wxImage *) 0 ;
12103 wxRect *arg2 = 0 ;
12104 SwigValueWrapper<wxImage > result;
12105 wxRect temp2 ;
12106 PyObject * obj0 = 0 ;
12107 PyObject * obj1 = 0 ;
12108 char *kwnames[] = {
12109 (char *) "self",(char *) "rect", NULL
12110 };
12111
12112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12114 if (SWIG_arg_fail(1)) SWIG_fail;
12115 {
12116 arg2 = &temp2;
12117 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12118 }
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12122
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 {
12127 wxImage * resultptr;
12128 resultptr = new wxImage((wxImage &)(result));
12129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12130 }
12131 return resultobj;
12132 fail:
12133 return NULL;
12134 }
12135
12136
12137 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12138 PyObject *resultobj;
12139 wxImage *arg1 = (wxImage *) 0 ;
12140 SwigValueWrapper<wxImage > result;
12141 PyObject * obj0 = 0 ;
12142 char *kwnames[] = {
12143 (char *) "self", NULL
12144 };
12145
12146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12148 if (SWIG_arg_fail(1)) SWIG_fail;
12149 {
12150 PyThreadState* __tstate = wxPyBeginAllowThreads();
12151 result = (arg1)->Copy();
12152
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 {
12157 wxImage * resultptr;
12158 resultptr = new wxImage((wxImage &)(result));
12159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12160 }
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj;
12169 wxImage *arg1 = (wxImage *) 0 ;
12170 wxImage *arg2 = 0 ;
12171 int arg3 ;
12172 int arg4 ;
12173 PyObject * obj0 = 0 ;
12174 PyObject * obj1 = 0 ;
12175 PyObject * obj2 = 0 ;
12176 PyObject * obj3 = 0 ;
12177 char *kwnames[] = {
12178 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12179 };
12180
12181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12183 if (SWIG_arg_fail(1)) SWIG_fail;
12184 {
12185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12186 if (SWIG_arg_fail(2)) SWIG_fail;
12187 if (arg2 == NULL) {
12188 SWIG_null_ref("wxImage");
12189 }
12190 if (SWIG_arg_fail(2)) SWIG_fail;
12191 }
12192 {
12193 arg3 = (int)(SWIG_As_int(obj2));
12194 if (SWIG_arg_fail(3)) SWIG_fail;
12195 }
12196 {
12197 arg4 = (int)(SWIG_As_int(obj3));
12198 if (SWIG_arg_fail(4)) SWIG_fail;
12199 }
12200 {
12201 PyThreadState* __tstate = wxPyBeginAllowThreads();
12202 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12203
12204 wxPyEndAllowThreads(__tstate);
12205 if (PyErr_Occurred()) SWIG_fail;
12206 }
12207 Py_INCREF(Py_None); resultobj = Py_None;
12208 return resultobj;
12209 fail:
12210 return NULL;
12211 }
12212
12213
12214 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12215 PyObject *resultobj;
12216 wxImage *arg1 = (wxImage *) 0 ;
12217 PyObject *result;
12218 PyObject * obj0 = 0 ;
12219 char *kwnames[] = {
12220 (char *) "self", NULL
12221 };
12222
12223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12225 if (SWIG_arg_fail(1)) SWIG_fail;
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (PyObject *)wxImage_GetData(arg1);
12229
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = result;
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj;
12242 wxImage *arg1 = (wxImage *) 0 ;
12243 PyObject *arg2 = (PyObject *) 0 ;
12244 PyObject * obj0 = 0 ;
12245 PyObject * obj1 = 0 ;
12246 char *kwnames[] = {
12247 (char *) "self",(char *) "data", NULL
12248 };
12249
12250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12252 if (SWIG_arg_fail(1)) SWIG_fail;
12253 arg2 = obj1;
12254 {
12255 PyThreadState* __tstate = wxPyBeginAllowThreads();
12256 wxImage_SetData(arg1,arg2);
12257
12258 wxPyEndAllowThreads(__tstate);
12259 if (PyErr_Occurred()) SWIG_fail;
12260 }
12261 Py_INCREF(Py_None); resultobj = Py_None;
12262 return resultobj;
12263 fail:
12264 return NULL;
12265 }
12266
12267
12268 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12269 PyObject *resultobj;
12270 wxImage *arg1 = (wxImage *) 0 ;
12271 PyObject *result;
12272 PyObject * obj0 = 0 ;
12273 char *kwnames[] = {
12274 (char *) "self", NULL
12275 };
12276
12277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12279 if (SWIG_arg_fail(1)) SWIG_fail;
12280 {
12281 PyThreadState* __tstate = wxPyBeginAllowThreads();
12282 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12283
12284 wxPyEndAllowThreads(__tstate);
12285 if (PyErr_Occurred()) SWIG_fail;
12286 }
12287 resultobj = result;
12288 return resultobj;
12289 fail:
12290 return NULL;
12291 }
12292
12293
12294 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12295 PyObject *resultobj;
12296 wxImage *arg1 = (wxImage *) 0 ;
12297 PyObject *arg2 = (PyObject *) 0 ;
12298 PyObject * obj0 = 0 ;
12299 PyObject * obj1 = 0 ;
12300 char *kwnames[] = {
12301 (char *) "self",(char *) "data", NULL
12302 };
12303
12304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12306 if (SWIG_arg_fail(1)) SWIG_fail;
12307 arg2 = obj1;
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 wxImage_SetDataBuffer(arg1,arg2);
12311
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 Py_INCREF(Py_None); resultobj = Py_None;
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj;
12324 wxImage *arg1 = (wxImage *) 0 ;
12325 PyObject *result;
12326 PyObject * obj0 = 0 ;
12327 char *kwnames[] = {
12328 (char *) "self", NULL
12329 };
12330
12331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12333 if (SWIG_arg_fail(1)) SWIG_fail;
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 result = (PyObject *)wxImage_GetAlphaData(arg1);
12337
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 resultobj = result;
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12349 PyObject *resultobj;
12350 wxImage *arg1 = (wxImage *) 0 ;
12351 PyObject *arg2 = (PyObject *) 0 ;
12352 PyObject * obj0 = 0 ;
12353 PyObject * obj1 = 0 ;
12354 char *kwnames[] = {
12355 (char *) "self",(char *) "data", NULL
12356 };
12357
12358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12360 if (SWIG_arg_fail(1)) SWIG_fail;
12361 arg2 = obj1;
12362 {
12363 PyThreadState* __tstate = wxPyBeginAllowThreads();
12364 wxImage_SetAlphaData(arg1,arg2);
12365
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 Py_INCREF(Py_None); resultobj = Py_None;
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxImage *arg1 = (wxImage *) 0 ;
12379 PyObject *result;
12380 PyObject * obj0 = 0 ;
12381 char *kwnames[] = {
12382 (char *) "self", NULL
12383 };
12384
12385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12387 if (SWIG_arg_fail(1)) SWIG_fail;
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12391
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 resultobj = result;
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj;
12404 wxImage *arg1 = (wxImage *) 0 ;
12405 PyObject *arg2 = (PyObject *) 0 ;
12406 PyObject * obj0 = 0 ;
12407 PyObject * obj1 = 0 ;
12408 char *kwnames[] = {
12409 (char *) "self",(char *) "data", NULL
12410 };
12411
12412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12414 if (SWIG_arg_fail(1)) SWIG_fail;
12415 arg2 = obj1;
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 wxImage_SetAlphaBuffer(arg1,arg2);
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 Py_INCREF(Py_None); resultobj = Py_None;
12424 return resultobj;
12425 fail:
12426 return NULL;
12427 }
12428
12429
12430 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12431 PyObject *resultobj;
12432 wxImage *arg1 = (wxImage *) 0 ;
12433 unsigned char arg2 ;
12434 unsigned char arg3 ;
12435 unsigned char arg4 ;
12436 PyObject * obj0 = 0 ;
12437 PyObject * obj1 = 0 ;
12438 PyObject * obj2 = 0 ;
12439 PyObject * obj3 = 0 ;
12440 char *kwnames[] = {
12441 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12442 };
12443
12444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12446 if (SWIG_arg_fail(1)) SWIG_fail;
12447 {
12448 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12449 if (SWIG_arg_fail(2)) SWIG_fail;
12450 }
12451 {
12452 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12453 if (SWIG_arg_fail(3)) SWIG_fail;
12454 }
12455 {
12456 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12457 if (SWIG_arg_fail(4)) SWIG_fail;
12458 }
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 (arg1)->SetMaskColour(arg2,arg3,arg4);
12462
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 Py_INCREF(Py_None); resultobj = Py_None;
12467 return resultobj;
12468 fail:
12469 return NULL;
12470 }
12471
12472
12473 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12474 PyObject *resultobj;
12475 wxImage *arg1 = (wxImage *) 0 ;
12476 unsigned char result;
12477 PyObject * obj0 = 0 ;
12478 char *kwnames[] = {
12479 (char *) "self", NULL
12480 };
12481
12482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12484 if (SWIG_arg_fail(1)) SWIG_fail;
12485 {
12486 PyThreadState* __tstate = wxPyBeginAllowThreads();
12487 result = (unsigned char)(arg1)->GetMaskRed();
12488
12489 wxPyEndAllowThreads(__tstate);
12490 if (PyErr_Occurred()) SWIG_fail;
12491 }
12492 {
12493 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12494 }
12495 return resultobj;
12496 fail:
12497 return NULL;
12498 }
12499
12500
12501 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12502 PyObject *resultobj;
12503 wxImage *arg1 = (wxImage *) 0 ;
12504 unsigned char result;
12505 PyObject * obj0 = 0 ;
12506 char *kwnames[] = {
12507 (char *) "self", NULL
12508 };
12509
12510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12512 if (SWIG_arg_fail(1)) SWIG_fail;
12513 {
12514 PyThreadState* __tstate = wxPyBeginAllowThreads();
12515 result = (unsigned char)(arg1)->GetMaskGreen();
12516
12517 wxPyEndAllowThreads(__tstate);
12518 if (PyErr_Occurred()) SWIG_fail;
12519 }
12520 {
12521 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12522 }
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj;
12531 wxImage *arg1 = (wxImage *) 0 ;
12532 unsigned char result;
12533 PyObject * obj0 = 0 ;
12534 char *kwnames[] = {
12535 (char *) "self", NULL
12536 };
12537
12538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) 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 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 result = (unsigned char)(arg1)->GetMaskBlue();
12544
12545 wxPyEndAllowThreads(__tstate);
12546 if (PyErr_Occurred()) SWIG_fail;
12547 }
12548 {
12549 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12550 }
12551 return resultobj;
12552 fail:
12553 return NULL;
12554 }
12555
12556
12557 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12558 PyObject *resultobj;
12559 wxImage *arg1 = (wxImage *) 0 ;
12560 bool arg2 = (bool) true ;
12561 PyObject * obj0 = 0 ;
12562 PyObject * obj1 = 0 ;
12563 char *kwnames[] = {
12564 (char *) "self",(char *) "mask", NULL
12565 };
12566
12567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12569 if (SWIG_arg_fail(1)) SWIG_fail;
12570 if (obj1) {
12571 {
12572 arg2 = (bool)(SWIG_As_bool(obj1));
12573 if (SWIG_arg_fail(2)) SWIG_fail;
12574 }
12575 }
12576 {
12577 PyThreadState* __tstate = wxPyBeginAllowThreads();
12578 (arg1)->SetMask(arg2);
12579
12580 wxPyEndAllowThreads(__tstate);
12581 if (PyErr_Occurred()) SWIG_fail;
12582 }
12583 Py_INCREF(Py_None); resultobj = Py_None;
12584 return resultobj;
12585 fail:
12586 return NULL;
12587 }
12588
12589
12590 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12591 PyObject *resultobj;
12592 wxImage *arg1 = (wxImage *) 0 ;
12593 bool result;
12594 PyObject * obj0 = 0 ;
12595 char *kwnames[] = {
12596 (char *) "self", NULL
12597 };
12598
12599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12601 if (SWIG_arg_fail(1)) SWIG_fail;
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 result = (bool)(arg1)->HasMask();
12605
12606 wxPyEndAllowThreads(__tstate);
12607 if (PyErr_Occurred()) SWIG_fail;
12608 }
12609 {
12610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12611 }
12612 return resultobj;
12613 fail:
12614 return NULL;
12615 }
12616
12617
12618 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12619 PyObject *resultobj;
12620 wxImage *arg1 = (wxImage *) 0 ;
12621 double arg2 ;
12622 wxPoint *arg3 = 0 ;
12623 bool arg4 = (bool) true ;
12624 wxPoint *arg5 = (wxPoint *) NULL ;
12625 SwigValueWrapper<wxImage > result;
12626 wxPoint temp3 ;
12627 PyObject * obj0 = 0 ;
12628 PyObject * obj1 = 0 ;
12629 PyObject * obj2 = 0 ;
12630 PyObject * obj3 = 0 ;
12631 PyObject * obj4 = 0 ;
12632 char *kwnames[] = {
12633 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12634 };
12635
12636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12638 if (SWIG_arg_fail(1)) SWIG_fail;
12639 {
12640 arg2 = (double)(SWIG_As_double(obj1));
12641 if (SWIG_arg_fail(2)) SWIG_fail;
12642 }
12643 {
12644 arg3 = &temp3;
12645 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12646 }
12647 if (obj3) {
12648 {
12649 arg4 = (bool)(SWIG_As_bool(obj3));
12650 if (SWIG_arg_fail(4)) SWIG_fail;
12651 }
12652 }
12653 if (obj4) {
12654 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12655 if (SWIG_arg_fail(5)) SWIG_fail;
12656 }
12657 {
12658 PyThreadState* __tstate = wxPyBeginAllowThreads();
12659 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12660
12661 wxPyEndAllowThreads(__tstate);
12662 if (PyErr_Occurred()) SWIG_fail;
12663 }
12664 {
12665 wxImage * resultptr;
12666 resultptr = new wxImage((wxImage &)(result));
12667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12668 }
12669 return resultobj;
12670 fail:
12671 return NULL;
12672 }
12673
12674
12675 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj;
12677 wxImage *arg1 = (wxImage *) 0 ;
12678 bool arg2 = (bool) true ;
12679 SwigValueWrapper<wxImage > result;
12680 PyObject * obj0 = 0 ;
12681 PyObject * obj1 = 0 ;
12682 char *kwnames[] = {
12683 (char *) "self",(char *) "clockwise", NULL
12684 };
12685
12686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12688 if (SWIG_arg_fail(1)) SWIG_fail;
12689 if (obj1) {
12690 {
12691 arg2 = (bool)(SWIG_As_bool(obj1));
12692 if (SWIG_arg_fail(2)) SWIG_fail;
12693 }
12694 }
12695 {
12696 PyThreadState* __tstate = wxPyBeginAllowThreads();
12697 result = (arg1)->Rotate90(arg2);
12698
12699 wxPyEndAllowThreads(__tstate);
12700 if (PyErr_Occurred()) SWIG_fail;
12701 }
12702 {
12703 wxImage * resultptr;
12704 resultptr = new wxImage((wxImage &)(result));
12705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12706 }
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12714 PyObject *resultobj;
12715 wxImage *arg1 = (wxImage *) 0 ;
12716 bool arg2 = (bool) true ;
12717 SwigValueWrapper<wxImage > result;
12718 PyObject * obj0 = 0 ;
12719 PyObject * obj1 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self",(char *) "horizontally", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 if (obj1) {
12728 {
12729 arg2 = (bool)(SWIG_As_bool(obj1));
12730 if (SWIG_arg_fail(2)) SWIG_fail;
12731 }
12732 }
12733 {
12734 PyThreadState* __tstate = wxPyBeginAllowThreads();
12735 result = (arg1)->Mirror(arg2);
12736
12737 wxPyEndAllowThreads(__tstate);
12738 if (PyErr_Occurred()) SWIG_fail;
12739 }
12740 {
12741 wxImage * resultptr;
12742 resultptr = new wxImage((wxImage &)(result));
12743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12744 }
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12752 PyObject *resultobj;
12753 wxImage *arg1 = (wxImage *) 0 ;
12754 unsigned char arg2 ;
12755 unsigned char arg3 ;
12756 unsigned char arg4 ;
12757 unsigned char arg5 ;
12758 unsigned char arg6 ;
12759 unsigned char arg7 ;
12760 PyObject * obj0 = 0 ;
12761 PyObject * obj1 = 0 ;
12762 PyObject * obj2 = 0 ;
12763 PyObject * obj3 = 0 ;
12764 PyObject * obj4 = 0 ;
12765 PyObject * obj5 = 0 ;
12766 PyObject * obj6 = 0 ;
12767 char *kwnames[] = {
12768 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12769 };
12770
12771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12773 if (SWIG_arg_fail(1)) SWIG_fail;
12774 {
12775 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12776 if (SWIG_arg_fail(2)) SWIG_fail;
12777 }
12778 {
12779 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12780 if (SWIG_arg_fail(3)) SWIG_fail;
12781 }
12782 {
12783 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12784 if (SWIG_arg_fail(4)) SWIG_fail;
12785 }
12786 {
12787 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12788 if (SWIG_arg_fail(5)) SWIG_fail;
12789 }
12790 {
12791 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12792 if (SWIG_arg_fail(6)) SWIG_fail;
12793 }
12794 {
12795 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12796 if (SWIG_arg_fail(7)) SWIG_fail;
12797 }
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12801
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 Py_INCREF(Py_None); resultobj = Py_None;
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj;
12814 wxImage *arg1 = (wxImage *) 0 ;
12815 unsigned char arg2 ;
12816 unsigned char arg3 ;
12817 unsigned char arg4 ;
12818 SwigValueWrapper<wxImage > result;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 PyObject * obj2 = 0 ;
12822 PyObject * obj3 = 0 ;
12823 char *kwnames[] = {
12824 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12825 };
12826
12827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12829 if (SWIG_arg_fail(1)) SWIG_fail;
12830 {
12831 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12832 if (SWIG_arg_fail(2)) SWIG_fail;
12833 }
12834 {
12835 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12836 if (SWIG_arg_fail(3)) SWIG_fail;
12837 }
12838 {
12839 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12840 if (SWIG_arg_fail(4)) SWIG_fail;
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 wxImage * resultptr;
12851 resultptr = new wxImage((wxImage &)(result));
12852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12853 }
12854 return resultobj;
12855 fail:
12856 return NULL;
12857 }
12858
12859
12860 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12861 PyObject *resultobj;
12862 wxImage *arg1 = (wxImage *) 0 ;
12863 wxString *arg2 = 0 ;
12864 wxString *arg3 = 0 ;
12865 bool temp2 = false ;
12866 bool temp3 = false ;
12867 PyObject * obj0 = 0 ;
12868 PyObject * obj1 = 0 ;
12869 PyObject * obj2 = 0 ;
12870 char *kwnames[] = {
12871 (char *) "self",(char *) "name",(char *) "value", NULL
12872 };
12873
12874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12876 if (SWIG_arg_fail(1)) SWIG_fail;
12877 {
12878 arg2 = wxString_in_helper(obj1);
12879 if (arg2 == NULL) SWIG_fail;
12880 temp2 = true;
12881 }
12882 {
12883 arg3 = wxString_in_helper(obj2);
12884 if (arg3 == NULL) SWIG_fail;
12885 temp3 = true;
12886 }
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12890
12891 wxPyEndAllowThreads(__tstate);
12892 if (PyErr_Occurred()) SWIG_fail;
12893 }
12894 Py_INCREF(Py_None); resultobj = Py_None;
12895 {
12896 if (temp2)
12897 delete arg2;
12898 }
12899 {
12900 if (temp3)
12901 delete arg3;
12902 }
12903 return resultobj;
12904 fail:
12905 {
12906 if (temp2)
12907 delete arg2;
12908 }
12909 {
12910 if (temp3)
12911 delete arg3;
12912 }
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj;
12919 wxImage *arg1 = (wxImage *) 0 ;
12920 wxString *arg2 = 0 ;
12921 int arg3 ;
12922 bool temp2 = false ;
12923 PyObject * obj0 = 0 ;
12924 PyObject * obj1 = 0 ;
12925 PyObject * obj2 = 0 ;
12926 char *kwnames[] = {
12927 (char *) "self",(char *) "name",(char *) "value", NULL
12928 };
12929
12930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12932 if (SWIG_arg_fail(1)) SWIG_fail;
12933 {
12934 arg2 = wxString_in_helper(obj1);
12935 if (arg2 == NULL) SWIG_fail;
12936 temp2 = true;
12937 }
12938 {
12939 arg3 = (int)(SWIG_As_int(obj2));
12940 if (SWIG_arg_fail(3)) SWIG_fail;
12941 }
12942 {
12943 PyThreadState* __tstate = wxPyBeginAllowThreads();
12944 (arg1)->SetOption((wxString const &)*arg2,arg3);
12945
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 Py_INCREF(Py_None); resultobj = Py_None;
12950 {
12951 if (temp2)
12952 delete arg2;
12953 }
12954 return resultobj;
12955 fail:
12956 {
12957 if (temp2)
12958 delete arg2;
12959 }
12960 return NULL;
12961 }
12962
12963
12964 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12965 PyObject *resultobj;
12966 wxImage *arg1 = (wxImage *) 0 ;
12967 wxString *arg2 = 0 ;
12968 wxString result;
12969 bool temp2 = false ;
12970 PyObject * obj0 = 0 ;
12971 PyObject * obj1 = 0 ;
12972 char *kwnames[] = {
12973 (char *) "self",(char *) "name", NULL
12974 };
12975
12976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12978 if (SWIG_arg_fail(1)) SWIG_fail;
12979 {
12980 arg2 = wxString_in_helper(obj1);
12981 if (arg2 == NULL) SWIG_fail;
12982 temp2 = true;
12983 }
12984 {
12985 PyThreadState* __tstate = wxPyBeginAllowThreads();
12986 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12987
12988 wxPyEndAllowThreads(__tstate);
12989 if (PyErr_Occurred()) SWIG_fail;
12990 }
12991 {
12992 #if wxUSE_UNICODE
12993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12994 #else
12995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12996 #endif
12997 }
12998 {
12999 if (temp2)
13000 delete arg2;
13001 }
13002 return resultobj;
13003 fail:
13004 {
13005 if (temp2)
13006 delete arg2;
13007 }
13008 return NULL;
13009 }
13010
13011
13012 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13013 PyObject *resultobj;
13014 wxImage *arg1 = (wxImage *) 0 ;
13015 wxString *arg2 = 0 ;
13016 int result;
13017 bool temp2 = false ;
13018 PyObject * obj0 = 0 ;
13019 PyObject * obj1 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self",(char *) "name", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 arg2 = wxString_in_helper(obj1);
13029 if (arg2 == NULL) SWIG_fail;
13030 temp2 = true;
13031 }
13032 {
13033 PyThreadState* __tstate = wxPyBeginAllowThreads();
13034 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13035
13036 wxPyEndAllowThreads(__tstate);
13037 if (PyErr_Occurred()) SWIG_fail;
13038 }
13039 {
13040 resultobj = SWIG_From_int((int)(result));
13041 }
13042 {
13043 if (temp2)
13044 delete arg2;
13045 }
13046 return resultobj;
13047 fail:
13048 {
13049 if (temp2)
13050 delete arg2;
13051 }
13052 return NULL;
13053 }
13054
13055
13056 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13057 PyObject *resultobj;
13058 wxImage *arg1 = (wxImage *) 0 ;
13059 wxString *arg2 = 0 ;
13060 bool result;
13061 bool temp2 = false ;
13062 PyObject * obj0 = 0 ;
13063 PyObject * obj1 = 0 ;
13064 char *kwnames[] = {
13065 (char *) "self",(char *) "name", NULL
13066 };
13067
13068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13070 if (SWIG_arg_fail(1)) SWIG_fail;
13071 {
13072 arg2 = wxString_in_helper(obj1);
13073 if (arg2 == NULL) SWIG_fail;
13074 temp2 = true;
13075 }
13076 {
13077 PyThreadState* __tstate = wxPyBeginAllowThreads();
13078 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13079
13080 wxPyEndAllowThreads(__tstate);
13081 if (PyErr_Occurred()) SWIG_fail;
13082 }
13083 {
13084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13085 }
13086 {
13087 if (temp2)
13088 delete arg2;
13089 }
13090 return resultobj;
13091 fail:
13092 {
13093 if (temp2)
13094 delete arg2;
13095 }
13096 return NULL;
13097 }
13098
13099
13100 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13101 PyObject *resultobj;
13102 wxImage *arg1 = (wxImage *) 0 ;
13103 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13104 unsigned long result;
13105 PyObject * obj0 = 0 ;
13106 PyObject * obj1 = 0 ;
13107 char *kwnames[] = {
13108 (char *) "self",(char *) "stopafter", NULL
13109 };
13110
13111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13113 if (SWIG_arg_fail(1)) SWIG_fail;
13114 if (obj1) {
13115 {
13116 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13117 if (SWIG_arg_fail(2)) SWIG_fail;
13118 }
13119 }
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (unsigned long)(arg1)->CountColours(arg2);
13123
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 {
13128 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13129 }
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13137 PyObject *resultobj;
13138 wxImage *arg1 = (wxImage *) 0 ;
13139 wxImageHistogram *arg2 = 0 ;
13140 unsigned long result;
13141 PyObject * obj0 = 0 ;
13142 PyObject * obj1 = 0 ;
13143 char *kwnames[] = {
13144 (char *) "self",(char *) "h", NULL
13145 };
13146
13147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13149 if (SWIG_arg_fail(1)) SWIG_fail;
13150 {
13151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13152 if (SWIG_arg_fail(2)) SWIG_fail;
13153 if (arg2 == NULL) {
13154 SWIG_null_ref("wxImageHistogram");
13155 }
13156 if (SWIG_arg_fail(2)) SWIG_fail;
13157 }
13158 {
13159 PyThreadState* __tstate = wxPyBeginAllowThreads();
13160 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13161
13162 wxPyEndAllowThreads(__tstate);
13163 if (PyErr_Occurred()) SWIG_fail;
13164 }
13165 {
13166 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13167 }
13168 return resultobj;
13169 fail:
13170 return NULL;
13171 }
13172
13173
13174 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13175 PyObject *resultobj;
13176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13177 PyObject * obj0 = 0 ;
13178 char *kwnames[] = {
13179 (char *) "handler", NULL
13180 };
13181
13182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13184 if (SWIG_arg_fail(1)) SWIG_fail;
13185 {
13186 PyThreadState* __tstate = wxPyBeginAllowThreads();
13187 wxImage::AddHandler(arg1);
13188
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 Py_INCREF(Py_None); resultobj = Py_None;
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13200 PyObject *resultobj;
13201 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13202 PyObject * obj0 = 0 ;
13203 char *kwnames[] = {
13204 (char *) "handler", NULL
13205 };
13206
13207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13209 if (SWIG_arg_fail(1)) SWIG_fail;
13210 {
13211 PyThreadState* __tstate = wxPyBeginAllowThreads();
13212 wxImage::InsertHandler(arg1);
13213
13214 wxPyEndAllowThreads(__tstate);
13215 if (PyErr_Occurred()) SWIG_fail;
13216 }
13217 Py_INCREF(Py_None); resultobj = Py_None;
13218 return resultobj;
13219 fail:
13220 return NULL;
13221 }
13222
13223
13224 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13225 PyObject *resultobj;
13226 wxString *arg1 = 0 ;
13227 bool result;
13228 bool temp1 = false ;
13229 PyObject * obj0 = 0 ;
13230 char *kwnames[] = {
13231 (char *) "name", NULL
13232 };
13233
13234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13235 {
13236 arg1 = wxString_in_helper(obj0);
13237 if (arg1 == NULL) SWIG_fail;
13238 temp1 = true;
13239 }
13240 {
13241 PyThreadState* __tstate = wxPyBeginAllowThreads();
13242 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13243
13244 wxPyEndAllowThreads(__tstate);
13245 if (PyErr_Occurred()) SWIG_fail;
13246 }
13247 {
13248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13249 }
13250 {
13251 if (temp1)
13252 delete arg1;
13253 }
13254 return resultobj;
13255 fail:
13256 {
13257 if (temp1)
13258 delete arg1;
13259 }
13260 return NULL;
13261 }
13262
13263
13264 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13265 PyObject *resultobj;
13266 wxString result;
13267 char *kwnames[] = {
13268 NULL
13269 };
13270
13271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = wxImage::GetImageExtWildcard();
13275
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 {
13280 #if wxUSE_UNICODE
13281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13282 #else
13283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13284 #endif
13285 }
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj;
13294 wxImage *arg1 = (wxImage *) 0 ;
13295 int arg2 = (int) -1 ;
13296 wxBitmap result;
13297 PyObject * obj0 = 0 ;
13298 PyObject * obj1 = 0 ;
13299 char *kwnames[] = {
13300 (char *) "self",(char *) "depth", NULL
13301 };
13302
13303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13305 if (SWIG_arg_fail(1)) SWIG_fail;
13306 if (obj1) {
13307 {
13308 arg2 = (int)(SWIG_As_int(obj1));
13309 if (SWIG_arg_fail(2)) SWIG_fail;
13310 }
13311 }
13312 {
13313 if (!wxPyCheckForApp()) SWIG_fail;
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = wxImage_ConvertToBitmap(arg1,arg2);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 {
13321 wxBitmap * resultptr;
13322 resultptr = new wxBitmap((wxBitmap &)(result));
13323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13324 }
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj;
13333 wxImage *arg1 = (wxImage *) 0 ;
13334 unsigned char arg2 ;
13335 unsigned char arg3 ;
13336 unsigned char arg4 ;
13337 wxBitmap result;
13338 PyObject * obj0 = 0 ;
13339 PyObject * obj1 = 0 ;
13340 PyObject * obj2 = 0 ;
13341 PyObject * obj3 = 0 ;
13342 char *kwnames[] = {
13343 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13344 };
13345
13346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13348 if (SWIG_arg_fail(1)) SWIG_fail;
13349 {
13350 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13351 if (SWIG_arg_fail(2)) SWIG_fail;
13352 }
13353 {
13354 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13355 if (SWIG_arg_fail(3)) SWIG_fail;
13356 }
13357 {
13358 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13359 if (SWIG_arg_fail(4)) SWIG_fail;
13360 }
13361 {
13362 if (!wxPyCheckForApp()) SWIG_fail;
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13365
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 {
13370 wxBitmap * resultptr;
13371 resultptr = new wxBitmap((wxBitmap &)(result));
13372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13373 }
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13381 PyObject *obj;
13382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13383 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13384 Py_INCREF(obj);
13385 return Py_BuildValue((char *)"");
13386 }
13387 static int _wrap_NullImage_set(PyObject *) {
13388 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13389 return 1;
13390 }
13391
13392
13393 static PyObject *_wrap_NullImage_get(void) {
13394 PyObject *pyobj;
13395
13396 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13397 return pyobj;
13398 }
13399
13400
13401 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13402 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13403 return 1;
13404 }
13405
13406
13407 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13408 PyObject *pyobj;
13409
13410 {
13411 #if wxUSE_UNICODE
13412 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13413 #else
13414 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13415 #endif
13416 }
13417 return pyobj;
13418 }
13419
13420
13421 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13422 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13423 return 1;
13424 }
13425
13426
13427 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13428 PyObject *pyobj;
13429
13430 {
13431 #if wxUSE_UNICODE
13432 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13433 #else
13434 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13435 #endif
13436 }
13437 return pyobj;
13438 }
13439
13440
13441 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13442 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13443 return 1;
13444 }
13445
13446
13447 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13448 PyObject *pyobj;
13449
13450 {
13451 #if wxUSE_UNICODE
13452 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13453 #else
13454 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13455 #endif
13456 }
13457 return pyobj;
13458 }
13459
13460
13461 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13462 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13463 return 1;
13464 }
13465
13466
13467 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13468 PyObject *pyobj;
13469
13470 {
13471 #if wxUSE_UNICODE
13472 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13473 #else
13474 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13475 #endif
13476 }
13477 return pyobj;
13478 }
13479
13480
13481 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13482 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13483 return 1;
13484 }
13485
13486
13487 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13488 PyObject *pyobj;
13489
13490 {
13491 #if wxUSE_UNICODE
13492 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13493 #else
13494 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13495 #endif
13496 }
13497 return pyobj;
13498 }
13499
13500
13501 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13502 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13503 return 1;
13504 }
13505
13506
13507 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13508 PyObject *pyobj;
13509
13510 {
13511 #if wxUSE_UNICODE
13512 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13513 #else
13514 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13515 #endif
13516 }
13517 return pyobj;
13518 }
13519
13520
13521 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13522 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13523 return 1;
13524 }
13525
13526
13527 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13528 PyObject *pyobj;
13529
13530 {
13531 #if wxUSE_UNICODE
13532 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13533 #else
13534 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13535 #endif
13536 }
13537 return pyobj;
13538 }
13539
13540
13541 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13542 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13543 return 1;
13544 }
13545
13546
13547 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13548 PyObject *pyobj;
13549
13550 {
13551 #if wxUSE_UNICODE
13552 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13553 #else
13554 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13555 #endif
13556 }
13557 return pyobj;
13558 }
13559
13560
13561 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13562 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13563 return 1;
13564 }
13565
13566
13567 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13568 PyObject *pyobj;
13569
13570 {
13571 #if wxUSE_UNICODE
13572 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13573 #else
13574 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13575 #endif
13576 }
13577 return pyobj;
13578 }
13579
13580
13581 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13582 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13583 return 1;
13584 }
13585
13586
13587 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13588 PyObject *pyobj;
13589
13590 {
13591 #if wxUSE_UNICODE
13592 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13593 #else
13594 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13595 #endif
13596 }
13597 return pyobj;
13598 }
13599
13600
13601 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13602 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13603 return 1;
13604 }
13605
13606
13607 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13608 PyObject *pyobj;
13609
13610 {
13611 #if wxUSE_UNICODE
13612 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13613 #else
13614 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13615 #endif
13616 }
13617 return pyobj;
13618 }
13619
13620
13621 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13622 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13623 return 1;
13624 }
13625
13626
13627 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13628 PyObject *pyobj;
13629
13630 {
13631 #if wxUSE_UNICODE
13632 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13633 #else
13634 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13635 #endif
13636 }
13637 return pyobj;
13638 }
13639
13640
13641 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj;
13643 wxBMPHandler *result;
13644 char *kwnames[] = {
13645 NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13649 {
13650 PyThreadState* __tstate = wxPyBeginAllowThreads();
13651 result = (wxBMPHandler *)new wxBMPHandler();
13652
13653 wxPyEndAllowThreads(__tstate);
13654 if (PyErr_Occurred()) SWIG_fail;
13655 }
13656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13657 return resultobj;
13658 fail:
13659 return NULL;
13660 }
13661
13662
13663 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13664 PyObject *obj;
13665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13666 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13667 Py_INCREF(obj);
13668 return Py_BuildValue((char *)"");
13669 }
13670 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13671 PyObject *resultobj;
13672 wxICOHandler *result;
13673 char *kwnames[] = {
13674 NULL
13675 };
13676
13677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13678 {
13679 PyThreadState* __tstate = wxPyBeginAllowThreads();
13680 result = (wxICOHandler *)new wxICOHandler();
13681
13682 wxPyEndAllowThreads(__tstate);
13683 if (PyErr_Occurred()) SWIG_fail;
13684 }
13685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13686 return resultobj;
13687 fail:
13688 return NULL;
13689 }
13690
13691
13692 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13693 PyObject *obj;
13694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13695 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13696 Py_INCREF(obj);
13697 return Py_BuildValue((char *)"");
13698 }
13699 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13700 PyObject *resultobj;
13701 wxCURHandler *result;
13702 char *kwnames[] = {
13703 NULL
13704 };
13705
13706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13707 {
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 result = (wxCURHandler *)new wxCURHandler();
13710
13711 wxPyEndAllowThreads(__tstate);
13712 if (PyErr_Occurred()) SWIG_fail;
13713 }
13714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13715 return resultobj;
13716 fail:
13717 return NULL;
13718 }
13719
13720
13721 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13722 PyObject *obj;
13723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13724 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13725 Py_INCREF(obj);
13726 return Py_BuildValue((char *)"");
13727 }
13728 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj;
13730 wxANIHandler *result;
13731 char *kwnames[] = {
13732 NULL
13733 };
13734
13735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 result = (wxANIHandler *)new wxANIHandler();
13739
13740 wxPyEndAllowThreads(__tstate);
13741 if (PyErr_Occurred()) SWIG_fail;
13742 }
13743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13744 return resultobj;
13745 fail:
13746 return NULL;
13747 }
13748
13749
13750 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13751 PyObject *obj;
13752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13753 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13754 Py_INCREF(obj);
13755 return Py_BuildValue((char *)"");
13756 }
13757 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj;
13759 wxPNGHandler *result;
13760 char *kwnames[] = {
13761 NULL
13762 };
13763
13764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 result = (wxPNGHandler *)new wxPNGHandler();
13768
13769 wxPyEndAllowThreads(__tstate);
13770 if (PyErr_Occurred()) SWIG_fail;
13771 }
13772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13773 return resultobj;
13774 fail:
13775 return NULL;
13776 }
13777
13778
13779 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13780 PyObject *obj;
13781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13782 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13783 Py_INCREF(obj);
13784 return Py_BuildValue((char *)"");
13785 }
13786 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13787 PyObject *resultobj;
13788 wxGIFHandler *result;
13789 char *kwnames[] = {
13790 NULL
13791 };
13792
13793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13794 {
13795 PyThreadState* __tstate = wxPyBeginAllowThreads();
13796 result = (wxGIFHandler *)new wxGIFHandler();
13797
13798 wxPyEndAllowThreads(__tstate);
13799 if (PyErr_Occurred()) SWIG_fail;
13800 }
13801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13809 PyObject *obj;
13810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13811 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13812 Py_INCREF(obj);
13813 return Py_BuildValue((char *)"");
13814 }
13815 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13816 PyObject *resultobj;
13817 wxPCXHandler *result;
13818 char *kwnames[] = {
13819 NULL
13820 };
13821
13822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13823 {
13824 PyThreadState* __tstate = wxPyBeginAllowThreads();
13825 result = (wxPCXHandler *)new wxPCXHandler();
13826
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13831 return resultobj;
13832 fail:
13833 return NULL;
13834 }
13835
13836
13837 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13838 PyObject *obj;
13839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13840 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13841 Py_INCREF(obj);
13842 return Py_BuildValue((char *)"");
13843 }
13844 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13845 PyObject *resultobj;
13846 wxJPEGHandler *result;
13847 char *kwnames[] = {
13848 NULL
13849 };
13850
13851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13852 {
13853 PyThreadState* __tstate = wxPyBeginAllowThreads();
13854 result = (wxJPEGHandler *)new wxJPEGHandler();
13855
13856 wxPyEndAllowThreads(__tstate);
13857 if (PyErr_Occurred()) SWIG_fail;
13858 }
13859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13860 return resultobj;
13861 fail:
13862 return NULL;
13863 }
13864
13865
13866 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13867 PyObject *obj;
13868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13869 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13870 Py_INCREF(obj);
13871 return Py_BuildValue((char *)"");
13872 }
13873 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj;
13875 wxPNMHandler *result;
13876 char *kwnames[] = {
13877 NULL
13878 };
13879
13880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 result = (wxPNMHandler *)new wxPNMHandler();
13884
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13889 return resultobj;
13890 fail:
13891 return NULL;
13892 }
13893
13894
13895 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13896 PyObject *obj;
13897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13898 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13899 Py_INCREF(obj);
13900 return Py_BuildValue((char *)"");
13901 }
13902 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj;
13904 wxXPMHandler *result;
13905 char *kwnames[] = {
13906 NULL
13907 };
13908
13909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13910 {
13911 PyThreadState* __tstate = wxPyBeginAllowThreads();
13912 result = (wxXPMHandler *)new wxXPMHandler();
13913
13914 wxPyEndAllowThreads(__tstate);
13915 if (PyErr_Occurred()) SWIG_fail;
13916 }
13917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13918 return resultobj;
13919 fail:
13920 return NULL;
13921 }
13922
13923
13924 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13925 PyObject *obj;
13926 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13927 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13928 Py_INCREF(obj);
13929 return Py_BuildValue((char *)"");
13930 }
13931 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13932 PyObject *resultobj;
13933 wxTIFFHandler *result;
13934 char *kwnames[] = {
13935 NULL
13936 };
13937
13938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 result = (wxTIFFHandler *)new wxTIFFHandler();
13942
13943 wxPyEndAllowThreads(__tstate);
13944 if (PyErr_Occurred()) SWIG_fail;
13945 }
13946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13947 return resultobj;
13948 fail:
13949 return NULL;
13950 }
13951
13952
13953 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13954 PyObject *obj;
13955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13956 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13957 Py_INCREF(obj);
13958 return Py_BuildValue((char *)"");
13959 }
13960 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj;
13962 wxImage *arg1 = 0 ;
13963 wxImage *arg2 = 0 ;
13964 int arg3 = (int) 236 ;
13965 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13966 bool result;
13967 PyObject * obj0 = 0 ;
13968 PyObject * obj1 = 0 ;
13969 PyObject * obj2 = 0 ;
13970 PyObject * obj3 = 0 ;
13971 char *kwnames[] = {
13972 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13973 };
13974
13975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13976 {
13977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13978 if (SWIG_arg_fail(1)) SWIG_fail;
13979 if (arg1 == NULL) {
13980 SWIG_null_ref("wxImage");
13981 }
13982 if (SWIG_arg_fail(1)) SWIG_fail;
13983 }
13984 {
13985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13986 if (SWIG_arg_fail(2)) SWIG_fail;
13987 if (arg2 == NULL) {
13988 SWIG_null_ref("wxImage");
13989 }
13990 if (SWIG_arg_fail(2)) SWIG_fail;
13991 }
13992 if (obj2) {
13993 {
13994 arg3 = (int)(SWIG_As_int(obj2));
13995 if (SWIG_arg_fail(3)) SWIG_fail;
13996 }
13997 }
13998 if (obj3) {
13999 {
14000 arg4 = (int)(SWIG_As_int(obj3));
14001 if (SWIG_arg_fail(4)) SWIG_fail;
14002 }
14003 }
14004 {
14005 PyThreadState* __tstate = wxPyBeginAllowThreads();
14006 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14007
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 {
14012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14013 }
14014 return resultobj;
14015 fail:
14016 return NULL;
14017 }
14018
14019
14020 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14021 PyObject *obj;
14022 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14023 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14024 Py_INCREF(obj);
14025 return Py_BuildValue((char *)"");
14026 }
14027 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14028 PyObject *resultobj;
14029 wxEvtHandler *result;
14030 char *kwnames[] = {
14031 NULL
14032 };
14033
14034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 result = (wxEvtHandler *)new wxEvtHandler();
14038
14039 wxPyEndAllowThreads(__tstate);
14040 if (PyErr_Occurred()) SWIG_fail;
14041 }
14042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14043 return resultobj;
14044 fail:
14045 return NULL;
14046 }
14047
14048
14049 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14050 PyObject *resultobj;
14051 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14052 wxEvtHandler *result;
14053 PyObject * obj0 = 0 ;
14054 char *kwnames[] = {
14055 (char *) "self", NULL
14056 };
14057
14058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14060 if (SWIG_arg_fail(1)) SWIG_fail;
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14064
14065 wxPyEndAllowThreads(__tstate);
14066 if (PyErr_Occurred()) SWIG_fail;
14067 }
14068 {
14069 resultobj = wxPyMake_wxObject(result, 0);
14070 }
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj;
14079 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14080 wxEvtHandler *result;
14081 PyObject * obj0 = 0 ;
14082 char *kwnames[] = {
14083 (char *) "self", NULL
14084 };
14085
14086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14088 if (SWIG_arg_fail(1)) SWIG_fail;
14089 {
14090 PyThreadState* __tstate = wxPyBeginAllowThreads();
14091 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14092
14093 wxPyEndAllowThreads(__tstate);
14094 if (PyErr_Occurred()) SWIG_fail;
14095 }
14096 {
14097 resultobj = wxPyMake_wxObject(result, 0);
14098 }
14099 return resultobj;
14100 fail:
14101 return NULL;
14102 }
14103
14104
14105 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14106 PyObject *resultobj;
14107 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14108 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14109 PyObject * obj0 = 0 ;
14110 PyObject * obj1 = 0 ;
14111 char *kwnames[] = {
14112 (char *) "self",(char *) "handler", NULL
14113 };
14114
14115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14117 if (SWIG_arg_fail(1)) SWIG_fail;
14118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14119 if (SWIG_arg_fail(2)) SWIG_fail;
14120 {
14121 PyThreadState* __tstate = wxPyBeginAllowThreads();
14122 (arg1)->SetNextHandler(arg2);
14123
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 Py_INCREF(Py_None); resultobj = Py_None;
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj;
14136 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14137 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14138 PyObject * obj0 = 0 ;
14139 PyObject * obj1 = 0 ;
14140 char *kwnames[] = {
14141 (char *) "self",(char *) "handler", NULL
14142 };
14143
14144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14146 if (SWIG_arg_fail(1)) SWIG_fail;
14147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14148 if (SWIG_arg_fail(2)) SWIG_fail;
14149 {
14150 PyThreadState* __tstate = wxPyBeginAllowThreads();
14151 (arg1)->SetPreviousHandler(arg2);
14152
14153 wxPyEndAllowThreads(__tstate);
14154 if (PyErr_Occurred()) SWIG_fail;
14155 }
14156 Py_INCREF(Py_None); resultobj = Py_None;
14157 return resultobj;
14158 fail:
14159 return NULL;
14160 }
14161
14162
14163 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14164 PyObject *resultobj;
14165 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14166 bool result;
14167 PyObject * obj0 = 0 ;
14168 char *kwnames[] = {
14169 (char *) "self", NULL
14170 };
14171
14172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14174 if (SWIG_arg_fail(1)) SWIG_fail;
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (bool)(arg1)->GetEvtHandlerEnabled();
14178
14179 wxPyEndAllowThreads(__tstate);
14180 if (PyErr_Occurred()) SWIG_fail;
14181 }
14182 {
14183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14184 }
14185 return resultobj;
14186 fail:
14187 return NULL;
14188 }
14189
14190
14191 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14192 PyObject *resultobj;
14193 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14194 bool arg2 ;
14195 PyObject * obj0 = 0 ;
14196 PyObject * obj1 = 0 ;
14197 char *kwnames[] = {
14198 (char *) "self",(char *) "enabled", NULL
14199 };
14200
14201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14203 if (SWIG_arg_fail(1)) SWIG_fail;
14204 {
14205 arg2 = (bool)(SWIG_As_bool(obj1));
14206 if (SWIG_arg_fail(2)) SWIG_fail;
14207 }
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 (arg1)->SetEvtHandlerEnabled(arg2);
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 Py_INCREF(Py_None); resultobj = Py_None;
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14223 PyObject *resultobj;
14224 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14225 wxEvent *arg2 = 0 ;
14226 bool result;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 char *kwnames[] = {
14230 (char *) "self",(char *) "event", NULL
14231 };
14232
14233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(1)) SWIG_fail;
14236 {
14237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14238 if (SWIG_arg_fail(2)) SWIG_fail;
14239 if (arg2 == NULL) {
14240 SWIG_null_ref("wxEvent");
14241 }
14242 if (SWIG_arg_fail(2)) SWIG_fail;
14243 }
14244 {
14245 PyThreadState* __tstate = wxPyBeginAllowThreads();
14246 result = (bool)(arg1)->ProcessEvent(*arg2);
14247
14248 wxPyEndAllowThreads(__tstate);
14249 if (PyErr_Occurred()) SWIG_fail;
14250 }
14251 {
14252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14253 }
14254 return resultobj;
14255 fail:
14256 return NULL;
14257 }
14258
14259
14260 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14261 PyObject *resultobj;
14262 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14263 wxEvent *arg2 = 0 ;
14264 PyObject * obj0 = 0 ;
14265 PyObject * obj1 = 0 ;
14266 char *kwnames[] = {
14267 (char *) "self",(char *) "event", NULL
14268 };
14269
14270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14272 if (SWIG_arg_fail(1)) SWIG_fail;
14273 {
14274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14275 if (SWIG_arg_fail(2)) SWIG_fail;
14276 if (arg2 == NULL) {
14277 SWIG_null_ref("wxEvent");
14278 }
14279 if (SWIG_arg_fail(2)) SWIG_fail;
14280 }
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 (arg1)->AddPendingEvent(*arg2);
14284
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 Py_INCREF(Py_None); resultobj = Py_None;
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj;
14297 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14298 PyObject * obj0 = 0 ;
14299 char *kwnames[] = {
14300 (char *) "self", NULL
14301 };
14302
14303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14305 if (SWIG_arg_fail(1)) SWIG_fail;
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 (arg1)->ProcessPendingEvents();
14309
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 Py_INCREF(Py_None); resultobj = Py_None;
14314 return resultobj;
14315 fail:
14316 return NULL;
14317 }
14318
14319
14320 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14321 PyObject *resultobj;
14322 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14323 int arg2 ;
14324 int arg3 ;
14325 int arg4 ;
14326 PyObject *arg5 = (PyObject *) 0 ;
14327 PyObject * obj0 = 0 ;
14328 PyObject * obj1 = 0 ;
14329 PyObject * obj2 = 0 ;
14330 PyObject * obj3 = 0 ;
14331 PyObject * obj4 = 0 ;
14332 char *kwnames[] = {
14333 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14334 };
14335
14336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14338 if (SWIG_arg_fail(1)) SWIG_fail;
14339 {
14340 arg2 = (int)(SWIG_As_int(obj1));
14341 if (SWIG_arg_fail(2)) SWIG_fail;
14342 }
14343 {
14344 arg3 = (int)(SWIG_As_int(obj2));
14345 if (SWIG_arg_fail(3)) SWIG_fail;
14346 }
14347 {
14348 arg4 = (int)(SWIG_As_int(obj3));
14349 if (SWIG_arg_fail(4)) SWIG_fail;
14350 }
14351 arg5 = obj4;
14352 {
14353 PyThreadState* __tstate = wxPyBeginAllowThreads();
14354 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14355
14356 wxPyEndAllowThreads(__tstate);
14357 if (PyErr_Occurred()) SWIG_fail;
14358 }
14359 Py_INCREF(Py_None); resultobj = Py_None;
14360 return resultobj;
14361 fail:
14362 return NULL;
14363 }
14364
14365
14366 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14367 PyObject *resultobj;
14368 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14369 int arg2 ;
14370 int arg3 = (int) -1 ;
14371 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14372 bool result;
14373 PyObject * obj0 = 0 ;
14374 PyObject * obj1 = 0 ;
14375 PyObject * obj2 = 0 ;
14376 PyObject * obj3 = 0 ;
14377 char *kwnames[] = {
14378 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14379 };
14380
14381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14383 if (SWIG_arg_fail(1)) SWIG_fail;
14384 {
14385 arg2 = (int)(SWIG_As_int(obj1));
14386 if (SWIG_arg_fail(2)) SWIG_fail;
14387 }
14388 if (obj2) {
14389 {
14390 arg3 = (int)(SWIG_As_int(obj2));
14391 if (SWIG_arg_fail(3)) SWIG_fail;
14392 }
14393 }
14394 if (obj3) {
14395 {
14396 arg4 = (wxEventType)(SWIG_As_int(obj3));
14397 if (SWIG_arg_fail(4)) SWIG_fail;
14398 }
14399 }
14400 {
14401 PyThreadState* __tstate = wxPyBeginAllowThreads();
14402 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14403
14404 wxPyEndAllowThreads(__tstate);
14405 if (PyErr_Occurred()) SWIG_fail;
14406 }
14407 {
14408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14409 }
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14419 PyObject *arg2 = (PyObject *) 0 ;
14420 bool arg3 = (bool) true ;
14421 PyObject * obj0 = 0 ;
14422 PyObject * obj1 = 0 ;
14423 PyObject * obj2 = 0 ;
14424 char *kwnames[] = {
14425 (char *) "self",(char *) "_self",(char *) "incref", NULL
14426 };
14427
14428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14430 if (SWIG_arg_fail(1)) SWIG_fail;
14431 arg2 = obj1;
14432 if (obj2) {
14433 {
14434 arg3 = (bool)(SWIG_As_bool(obj2));
14435 if (SWIG_arg_fail(3)) SWIG_fail;
14436 }
14437 }
14438 {
14439 PyThreadState* __tstate = wxPyBeginAllowThreads();
14440 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14441
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 Py_INCREF(Py_None); resultobj = Py_None;
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14453 PyObject *obj;
14454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14455 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14456 Py_INCREF(obj);
14457 return Py_BuildValue((char *)"");
14458 }
14459 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj;
14461 wxEventType result;
14462 char *kwnames[] = {
14463 NULL
14464 };
14465
14466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (wxEventType)wxNewEventType();
14470
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 {
14475 resultobj = SWIG_From_int((int)(result));
14476 }
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14484 PyObject *resultobj;
14485 wxEvent *arg1 = (wxEvent *) 0 ;
14486 PyObject * obj0 = 0 ;
14487 char *kwnames[] = {
14488 (char *) "self", NULL
14489 };
14490
14491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14493 if (SWIG_arg_fail(1)) SWIG_fail;
14494 {
14495 PyThreadState* __tstate = wxPyBeginAllowThreads();
14496 delete arg1;
14497
14498 wxPyEndAllowThreads(__tstate);
14499 if (PyErr_Occurred()) SWIG_fail;
14500 }
14501 Py_INCREF(Py_None); resultobj = Py_None;
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14509 PyObject *resultobj;
14510 wxEvent *arg1 = (wxEvent *) 0 ;
14511 wxEventType arg2 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 char *kwnames[] = {
14515 (char *) "self",(char *) "typ", NULL
14516 };
14517
14518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14520 if (SWIG_arg_fail(1)) SWIG_fail;
14521 {
14522 arg2 = (wxEventType)(SWIG_As_int(obj1));
14523 if (SWIG_arg_fail(2)) SWIG_fail;
14524 }
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 (arg1)->SetEventType(arg2);
14528
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 Py_INCREF(Py_None); resultobj = Py_None;
14533 return resultobj;
14534 fail:
14535 return NULL;
14536 }
14537
14538
14539 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14540 PyObject *resultobj;
14541 wxEvent *arg1 = (wxEvent *) 0 ;
14542 wxEventType result;
14543 PyObject * obj0 = 0 ;
14544 char *kwnames[] = {
14545 (char *) "self", NULL
14546 };
14547
14548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14550 if (SWIG_arg_fail(1)) SWIG_fail;
14551 {
14552 PyThreadState* __tstate = wxPyBeginAllowThreads();
14553 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14554
14555 wxPyEndAllowThreads(__tstate);
14556 if (PyErr_Occurred()) SWIG_fail;
14557 }
14558 {
14559 resultobj = SWIG_From_int((int)(result));
14560 }
14561 return resultobj;
14562 fail:
14563 return NULL;
14564 }
14565
14566
14567 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14568 PyObject *resultobj;
14569 wxEvent *arg1 = (wxEvent *) 0 ;
14570 wxObject *result;
14571 PyObject * obj0 = 0 ;
14572 char *kwnames[] = {
14573 (char *) "self", NULL
14574 };
14575
14576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14578 if (SWIG_arg_fail(1)) SWIG_fail;
14579 {
14580 PyThreadState* __tstate = wxPyBeginAllowThreads();
14581 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14582
14583 wxPyEndAllowThreads(__tstate);
14584 if (PyErr_Occurred()) SWIG_fail;
14585 }
14586 {
14587 resultobj = wxPyMake_wxObject(result, 0);
14588 }
14589 return resultobj;
14590 fail:
14591 return NULL;
14592 }
14593
14594
14595 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14596 PyObject *resultobj;
14597 wxEvent *arg1 = (wxEvent *) 0 ;
14598 wxObject *arg2 = (wxObject *) 0 ;
14599 PyObject * obj0 = 0 ;
14600 PyObject * obj1 = 0 ;
14601 char *kwnames[] = {
14602 (char *) "self",(char *) "obj", NULL
14603 };
14604
14605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14607 if (SWIG_arg_fail(1)) SWIG_fail;
14608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14609 if (SWIG_arg_fail(2)) SWIG_fail;
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 (arg1)->SetEventObject(arg2);
14613
14614 wxPyEndAllowThreads(__tstate);
14615 if (PyErr_Occurred()) SWIG_fail;
14616 }
14617 Py_INCREF(Py_None); resultobj = Py_None;
14618 return resultobj;
14619 fail:
14620 return NULL;
14621 }
14622
14623
14624 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14625 PyObject *resultobj;
14626 wxEvent *arg1 = (wxEvent *) 0 ;
14627 long result;
14628 PyObject * obj0 = 0 ;
14629 char *kwnames[] = {
14630 (char *) "self", NULL
14631 };
14632
14633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14635 if (SWIG_arg_fail(1)) SWIG_fail;
14636 {
14637 PyThreadState* __tstate = wxPyBeginAllowThreads();
14638 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14639
14640 wxPyEndAllowThreads(__tstate);
14641 if (PyErr_Occurred()) SWIG_fail;
14642 }
14643 {
14644 resultobj = SWIG_From_long((long)(result));
14645 }
14646 return resultobj;
14647 fail:
14648 return NULL;
14649 }
14650
14651
14652 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14653 PyObject *resultobj;
14654 wxEvent *arg1 = (wxEvent *) 0 ;
14655 long arg2 = (long) 0 ;
14656 PyObject * obj0 = 0 ;
14657 PyObject * obj1 = 0 ;
14658 char *kwnames[] = {
14659 (char *) "self",(char *) "ts", NULL
14660 };
14661
14662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14664 if (SWIG_arg_fail(1)) SWIG_fail;
14665 if (obj1) {
14666 {
14667 arg2 = (long)(SWIG_As_long(obj1));
14668 if (SWIG_arg_fail(2)) SWIG_fail;
14669 }
14670 }
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 (arg1)->SetTimestamp(arg2);
14674
14675 wxPyEndAllowThreads(__tstate);
14676 if (PyErr_Occurred()) SWIG_fail;
14677 }
14678 Py_INCREF(Py_None); resultobj = Py_None;
14679 return resultobj;
14680 fail:
14681 return NULL;
14682 }
14683
14684
14685 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14686 PyObject *resultobj;
14687 wxEvent *arg1 = (wxEvent *) 0 ;
14688 int result;
14689 PyObject * obj0 = 0 ;
14690 char *kwnames[] = {
14691 (char *) "self", NULL
14692 };
14693
14694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14696 if (SWIG_arg_fail(1)) SWIG_fail;
14697 {
14698 PyThreadState* __tstate = wxPyBeginAllowThreads();
14699 result = (int)((wxEvent const *)arg1)->GetId();
14700
14701 wxPyEndAllowThreads(__tstate);
14702 if (PyErr_Occurred()) SWIG_fail;
14703 }
14704 {
14705 resultobj = SWIG_From_int((int)(result));
14706 }
14707 return resultobj;
14708 fail:
14709 return NULL;
14710 }
14711
14712
14713 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14714 PyObject *resultobj;
14715 wxEvent *arg1 = (wxEvent *) 0 ;
14716 int arg2 ;
14717 PyObject * obj0 = 0 ;
14718 PyObject * obj1 = 0 ;
14719 char *kwnames[] = {
14720 (char *) "self",(char *) "Id", NULL
14721 };
14722
14723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14725 if (SWIG_arg_fail(1)) SWIG_fail;
14726 {
14727 arg2 = (int)(SWIG_As_int(obj1));
14728 if (SWIG_arg_fail(2)) SWIG_fail;
14729 }
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 (arg1)->SetId(arg2);
14733
14734 wxPyEndAllowThreads(__tstate);
14735 if (PyErr_Occurred()) SWIG_fail;
14736 }
14737 Py_INCREF(Py_None); resultobj = Py_None;
14738 return resultobj;
14739 fail:
14740 return NULL;
14741 }
14742
14743
14744 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14745 PyObject *resultobj;
14746 wxEvent *arg1 = (wxEvent *) 0 ;
14747 bool result;
14748 PyObject * obj0 = 0 ;
14749 char *kwnames[] = {
14750 (char *) "self", NULL
14751 };
14752
14753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14755 if (SWIG_arg_fail(1)) SWIG_fail;
14756 {
14757 PyThreadState* __tstate = wxPyBeginAllowThreads();
14758 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14759
14760 wxPyEndAllowThreads(__tstate);
14761 if (PyErr_Occurred()) SWIG_fail;
14762 }
14763 {
14764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14765 }
14766 return resultobj;
14767 fail:
14768 return NULL;
14769 }
14770
14771
14772 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14773 PyObject *resultobj;
14774 wxEvent *arg1 = (wxEvent *) 0 ;
14775 bool arg2 = (bool) true ;
14776 PyObject * obj0 = 0 ;
14777 PyObject * obj1 = 0 ;
14778 char *kwnames[] = {
14779 (char *) "self",(char *) "skip", NULL
14780 };
14781
14782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14784 if (SWIG_arg_fail(1)) SWIG_fail;
14785 if (obj1) {
14786 {
14787 arg2 = (bool)(SWIG_As_bool(obj1));
14788 if (SWIG_arg_fail(2)) SWIG_fail;
14789 }
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 (arg1)->Skip(arg2);
14794
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 Py_INCREF(Py_None); resultobj = Py_None;
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxEvent *arg1 = (wxEvent *) 0 ;
14808 bool result;
14809 PyObject * obj0 = 0 ;
14810 char *kwnames[] = {
14811 (char *) "self", NULL
14812 };
14813
14814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14816 if (SWIG_arg_fail(1)) SWIG_fail;
14817 {
14818 PyThreadState* __tstate = wxPyBeginAllowThreads();
14819 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14820
14821 wxPyEndAllowThreads(__tstate);
14822 if (PyErr_Occurred()) SWIG_fail;
14823 }
14824 {
14825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14826 }
14827 return resultobj;
14828 fail:
14829 return NULL;
14830 }
14831
14832
14833 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14834 PyObject *resultobj;
14835 wxEvent *arg1 = (wxEvent *) 0 ;
14836 bool result;
14837 PyObject * obj0 = 0 ;
14838 char *kwnames[] = {
14839 (char *) "self", NULL
14840 };
14841
14842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14844 if (SWIG_arg_fail(1)) SWIG_fail;
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14848
14849 wxPyEndAllowThreads(__tstate);
14850 if (PyErr_Occurred()) SWIG_fail;
14851 }
14852 {
14853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14854 }
14855 return resultobj;
14856 fail:
14857 return NULL;
14858 }
14859
14860
14861 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj;
14863 wxEvent *arg1 = (wxEvent *) 0 ;
14864 int result;
14865 PyObject * obj0 = 0 ;
14866 char *kwnames[] = {
14867 (char *) "self", NULL
14868 };
14869
14870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14872 if (SWIG_arg_fail(1)) SWIG_fail;
14873 {
14874 PyThreadState* __tstate = wxPyBeginAllowThreads();
14875 result = (int)(arg1)->StopPropagation();
14876
14877 wxPyEndAllowThreads(__tstate);
14878 if (PyErr_Occurred()) SWIG_fail;
14879 }
14880 {
14881 resultobj = SWIG_From_int((int)(result));
14882 }
14883 return resultobj;
14884 fail:
14885 return NULL;
14886 }
14887
14888
14889 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14890 PyObject *resultobj;
14891 wxEvent *arg1 = (wxEvent *) 0 ;
14892 int arg2 ;
14893 PyObject * obj0 = 0 ;
14894 PyObject * obj1 = 0 ;
14895 char *kwnames[] = {
14896 (char *) "self",(char *) "propagationLevel", NULL
14897 };
14898
14899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14901 if (SWIG_arg_fail(1)) SWIG_fail;
14902 {
14903 arg2 = (int)(SWIG_As_int(obj1));
14904 if (SWIG_arg_fail(2)) SWIG_fail;
14905 }
14906 {
14907 PyThreadState* __tstate = wxPyBeginAllowThreads();
14908 (arg1)->ResumePropagation(arg2);
14909
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 Py_INCREF(Py_None); resultobj = Py_None;
14914 return resultobj;
14915 fail:
14916 return NULL;
14917 }
14918
14919
14920 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14921 PyObject *resultobj;
14922 wxEvent *arg1 = (wxEvent *) 0 ;
14923 wxEvent *result;
14924 PyObject * obj0 = 0 ;
14925 char *kwnames[] = {
14926 (char *) "self", NULL
14927 };
14928
14929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14931 if (SWIG_arg_fail(1)) SWIG_fail;
14932 {
14933 PyThreadState* __tstate = wxPyBeginAllowThreads();
14934 result = (wxEvent *)(arg1)->Clone();
14935
14936 wxPyEndAllowThreads(__tstate);
14937 if (PyErr_Occurred()) SWIG_fail;
14938 }
14939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14940 return resultobj;
14941 fail:
14942 return NULL;
14943 }
14944
14945
14946 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14947 PyObject *obj;
14948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14949 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14950 Py_INCREF(obj);
14951 return Py_BuildValue((char *)"");
14952 }
14953 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14954 PyObject *resultobj;
14955 wxEvent *arg1 = 0 ;
14956 wxPropagationDisabler *result;
14957 PyObject * obj0 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "event", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14963 {
14964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14965 if (SWIG_arg_fail(1)) SWIG_fail;
14966 if (arg1 == NULL) {
14967 SWIG_null_ref("wxEvent");
14968 }
14969 if (SWIG_arg_fail(1)) SWIG_fail;
14970 }
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14974
14975 wxPyEndAllowThreads(__tstate);
14976 if (PyErr_Occurred()) SWIG_fail;
14977 }
14978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14979 return resultobj;
14980 fail:
14981 return NULL;
14982 }
14983
14984
14985 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14986 PyObject *resultobj;
14987 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14988 PyObject * obj0 = 0 ;
14989 char *kwnames[] = {
14990 (char *) "self", NULL
14991 };
14992
14993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14995 if (SWIG_arg_fail(1)) SWIG_fail;
14996 {
14997 PyThreadState* __tstate = wxPyBeginAllowThreads();
14998 delete arg1;
14999
15000 wxPyEndAllowThreads(__tstate);
15001 if (PyErr_Occurred()) SWIG_fail;
15002 }
15003 Py_INCREF(Py_None); resultobj = Py_None;
15004 return resultobj;
15005 fail:
15006 return NULL;
15007 }
15008
15009
15010 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15011 PyObject *obj;
15012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15013 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15014 Py_INCREF(obj);
15015 return Py_BuildValue((char *)"");
15016 }
15017 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15018 PyObject *resultobj;
15019 wxEvent *arg1 = 0 ;
15020 wxPropagateOnce *result;
15021 PyObject * obj0 = 0 ;
15022 char *kwnames[] = {
15023 (char *) "event", NULL
15024 };
15025
15026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15027 {
15028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15029 if (SWIG_arg_fail(1)) SWIG_fail;
15030 if (arg1 == NULL) {
15031 SWIG_null_ref("wxEvent");
15032 }
15033 if (SWIG_arg_fail(1)) SWIG_fail;
15034 }
15035 {
15036 PyThreadState* __tstate = wxPyBeginAllowThreads();
15037 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15038
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15043 return resultobj;
15044 fail:
15045 return NULL;
15046 }
15047
15048
15049 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15050 PyObject *resultobj;
15051 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15052 PyObject * obj0 = 0 ;
15053 char *kwnames[] = {
15054 (char *) "self", NULL
15055 };
15056
15057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15059 if (SWIG_arg_fail(1)) SWIG_fail;
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 delete arg1;
15063
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 Py_INCREF(Py_None); resultobj = Py_None;
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15075 PyObject *obj;
15076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15077 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15078 Py_INCREF(obj);
15079 return Py_BuildValue((char *)"");
15080 }
15081 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15084 int arg2 = (int) 0 ;
15085 wxCommandEvent *result;
15086 PyObject * obj0 = 0 ;
15087 PyObject * obj1 = 0 ;
15088 char *kwnames[] = {
15089 (char *) "commandType",(char *) "winid", NULL
15090 };
15091
15092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15093 if (obj0) {
15094 {
15095 arg1 = (wxEventType)(SWIG_As_int(obj0));
15096 if (SWIG_arg_fail(1)) SWIG_fail;
15097 }
15098 }
15099 if (obj1) {
15100 {
15101 arg2 = (int)(SWIG_As_int(obj1));
15102 if (SWIG_arg_fail(2)) SWIG_fail;
15103 }
15104 }
15105 {
15106 PyThreadState* __tstate = wxPyBeginAllowThreads();
15107 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15108
15109 wxPyEndAllowThreads(__tstate);
15110 if (PyErr_Occurred()) SWIG_fail;
15111 }
15112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15113 return resultobj;
15114 fail:
15115 return NULL;
15116 }
15117
15118
15119 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15120 PyObject *resultobj;
15121 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15122 int result;
15123 PyObject * obj0 = 0 ;
15124 char *kwnames[] = {
15125 (char *) "self", NULL
15126 };
15127
15128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15130 if (SWIG_arg_fail(1)) SWIG_fail;
15131 {
15132 PyThreadState* __tstate = wxPyBeginAllowThreads();
15133 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15134
15135 wxPyEndAllowThreads(__tstate);
15136 if (PyErr_Occurred()) SWIG_fail;
15137 }
15138 {
15139 resultobj = SWIG_From_int((int)(result));
15140 }
15141 return resultobj;
15142 fail:
15143 return NULL;
15144 }
15145
15146
15147 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15148 PyObject *resultobj;
15149 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15150 wxString *arg2 = 0 ;
15151 bool temp2 = false ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 char *kwnames[] = {
15155 (char *) "self",(char *) "s", NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(1)) SWIG_fail;
15161 {
15162 arg2 = wxString_in_helper(obj1);
15163 if (arg2 == NULL) SWIG_fail;
15164 temp2 = true;
15165 }
15166 {
15167 PyThreadState* __tstate = wxPyBeginAllowThreads();
15168 (arg1)->SetString((wxString const &)*arg2);
15169
15170 wxPyEndAllowThreads(__tstate);
15171 if (PyErr_Occurred()) SWIG_fail;
15172 }
15173 Py_INCREF(Py_None); resultobj = Py_None;
15174 {
15175 if (temp2)
15176 delete arg2;
15177 }
15178 return resultobj;
15179 fail:
15180 {
15181 if (temp2)
15182 delete arg2;
15183 }
15184 return NULL;
15185 }
15186
15187
15188 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15189 PyObject *resultobj;
15190 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15191 wxString result;
15192 PyObject * obj0 = 0 ;
15193 char *kwnames[] = {
15194 (char *) "self", NULL
15195 };
15196
15197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15199 if (SWIG_arg_fail(1)) SWIG_fail;
15200 {
15201 PyThreadState* __tstate = wxPyBeginAllowThreads();
15202 result = ((wxCommandEvent const *)arg1)->GetString();
15203
15204 wxPyEndAllowThreads(__tstate);
15205 if (PyErr_Occurred()) SWIG_fail;
15206 }
15207 {
15208 #if wxUSE_UNICODE
15209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15210 #else
15211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15212 #endif
15213 }
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj;
15222 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15223 bool result;
15224 PyObject * obj0 = 0 ;
15225 char *kwnames[] = {
15226 (char *) "self", NULL
15227 };
15228
15229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15231 if (SWIG_arg_fail(1)) SWIG_fail;
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15235
15236 wxPyEndAllowThreads(__tstate);
15237 if (PyErr_Occurred()) SWIG_fail;
15238 }
15239 {
15240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15241 }
15242 return resultobj;
15243 fail:
15244 return NULL;
15245 }
15246
15247
15248 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15249 PyObject *resultobj;
15250 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15251 bool result;
15252 PyObject * obj0 = 0 ;
15253 char *kwnames[] = {
15254 (char *) "self", NULL
15255 };
15256
15257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15259 if (SWIG_arg_fail(1)) SWIG_fail;
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 {
15268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15269 }
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15277 PyObject *resultobj;
15278 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15279 long arg2 ;
15280 PyObject * obj0 = 0 ;
15281 PyObject * obj1 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self",(char *) "extraLong", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 {
15290 arg2 = (long)(SWIG_As_long(obj1));
15291 if (SWIG_arg_fail(2)) SWIG_fail;
15292 }
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 (arg1)->SetExtraLong(arg2);
15296
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 Py_INCREF(Py_None); resultobj = Py_None;
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15308 PyObject *resultobj;
15309 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15310 long result;
15311 PyObject * obj0 = 0 ;
15312 char *kwnames[] = {
15313 (char *) "self", NULL
15314 };
15315
15316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15318 if (SWIG_arg_fail(1)) SWIG_fail;
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15322
15323 wxPyEndAllowThreads(__tstate);
15324 if (PyErr_Occurred()) SWIG_fail;
15325 }
15326 {
15327 resultobj = SWIG_From_long((long)(result));
15328 }
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15336 PyObject *resultobj;
15337 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15338 int arg2 ;
15339 PyObject * obj0 = 0 ;
15340 PyObject * obj1 = 0 ;
15341 char *kwnames[] = {
15342 (char *) "self",(char *) "i", NULL
15343 };
15344
15345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15347 if (SWIG_arg_fail(1)) SWIG_fail;
15348 {
15349 arg2 = (int)(SWIG_As_int(obj1));
15350 if (SWIG_arg_fail(2)) SWIG_fail;
15351 }
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 (arg1)->SetInt(arg2);
15355
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 Py_INCREF(Py_None); resultobj = Py_None;
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15367 PyObject *resultobj;
15368 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15369 long result;
15370 PyObject * obj0 = 0 ;
15371 char *kwnames[] = {
15372 (char *) "self", NULL
15373 };
15374
15375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15377 if (SWIG_arg_fail(1)) SWIG_fail;
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15381
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 {
15386 resultobj = SWIG_From_long((long)(result));
15387 }
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15395 PyObject *resultobj;
15396 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15397 wxEvent *result;
15398 PyObject * obj0 = 0 ;
15399 char *kwnames[] = {
15400 (char *) "self", NULL
15401 };
15402
15403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15405 if (SWIG_arg_fail(1)) SWIG_fail;
15406 {
15407 PyThreadState* __tstate = wxPyBeginAllowThreads();
15408 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15409
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15421 PyObject *obj;
15422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15423 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15424 Py_INCREF(obj);
15425 return Py_BuildValue((char *)"");
15426 }
15427 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj;
15429 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15430 int arg2 = (int) 0 ;
15431 wxNotifyEvent *result;
15432 PyObject * obj0 = 0 ;
15433 PyObject * obj1 = 0 ;
15434 char *kwnames[] = {
15435 (char *) "commandType",(char *) "winid", NULL
15436 };
15437
15438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15439 if (obj0) {
15440 {
15441 arg1 = (wxEventType)(SWIG_As_int(obj0));
15442 if (SWIG_arg_fail(1)) SWIG_fail;
15443 }
15444 }
15445 if (obj1) {
15446 {
15447 arg2 = (int)(SWIG_As_int(obj1));
15448 if (SWIG_arg_fail(2)) SWIG_fail;
15449 }
15450 }
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15454
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15466 PyObject *resultobj;
15467 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15468 PyObject * obj0 = 0 ;
15469 char *kwnames[] = {
15470 (char *) "self", NULL
15471 };
15472
15473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15475 if (SWIG_arg_fail(1)) SWIG_fail;
15476 {
15477 PyThreadState* __tstate = wxPyBeginAllowThreads();
15478 (arg1)->Veto();
15479
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 Py_INCREF(Py_None); resultobj = Py_None;
15484 return resultobj;
15485 fail:
15486 return NULL;
15487 }
15488
15489
15490 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj;
15492 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15493 PyObject * obj0 = 0 ;
15494 char *kwnames[] = {
15495 (char *) "self", NULL
15496 };
15497
15498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15500 if (SWIG_arg_fail(1)) SWIG_fail;
15501 {
15502 PyThreadState* __tstate = wxPyBeginAllowThreads();
15503 (arg1)->Allow();
15504
15505 wxPyEndAllowThreads(__tstate);
15506 if (PyErr_Occurred()) SWIG_fail;
15507 }
15508 Py_INCREF(Py_None); resultobj = Py_None;
15509 return resultobj;
15510 fail:
15511 return NULL;
15512 }
15513
15514
15515 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15516 PyObject *resultobj;
15517 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15518 bool result;
15519 PyObject * obj0 = 0 ;
15520 char *kwnames[] = {
15521 (char *) "self", NULL
15522 };
15523
15524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15526 if (SWIG_arg_fail(1)) SWIG_fail;
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 result = (bool)(arg1)->IsAllowed();
15530
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 {
15535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15536 }
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15544 PyObject *obj;
15545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15546 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15547 Py_INCREF(obj);
15548 return Py_BuildValue((char *)"");
15549 }
15550 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj;
15552 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15553 int arg2 = (int) 0 ;
15554 int arg3 = (int) 0 ;
15555 int arg4 = (int) 0 ;
15556 wxScrollEvent *result;
15557 PyObject * obj0 = 0 ;
15558 PyObject * obj1 = 0 ;
15559 PyObject * obj2 = 0 ;
15560 PyObject * obj3 = 0 ;
15561 char *kwnames[] = {
15562 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15563 };
15564
15565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15566 if (obj0) {
15567 {
15568 arg1 = (wxEventType)(SWIG_As_int(obj0));
15569 if (SWIG_arg_fail(1)) SWIG_fail;
15570 }
15571 }
15572 if (obj1) {
15573 {
15574 arg2 = (int)(SWIG_As_int(obj1));
15575 if (SWIG_arg_fail(2)) SWIG_fail;
15576 }
15577 }
15578 if (obj2) {
15579 {
15580 arg3 = (int)(SWIG_As_int(obj2));
15581 if (SWIG_arg_fail(3)) SWIG_fail;
15582 }
15583 }
15584 if (obj3) {
15585 {
15586 arg4 = (int)(SWIG_As_int(obj3));
15587 if (SWIG_arg_fail(4)) SWIG_fail;
15588 }
15589 }
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15593
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15598 return resultobj;
15599 fail:
15600 return NULL;
15601 }
15602
15603
15604 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15605 PyObject *resultobj;
15606 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15607 int result;
15608 PyObject * obj0 = 0 ;
15609 char *kwnames[] = {
15610 (char *) "self", NULL
15611 };
15612
15613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15615 if (SWIG_arg_fail(1)) SWIG_fail;
15616 {
15617 PyThreadState* __tstate = wxPyBeginAllowThreads();
15618 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15619
15620 wxPyEndAllowThreads(__tstate);
15621 if (PyErr_Occurred()) SWIG_fail;
15622 }
15623 {
15624 resultobj = SWIG_From_int((int)(result));
15625 }
15626 return resultobj;
15627 fail:
15628 return NULL;
15629 }
15630
15631
15632 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15633 PyObject *resultobj;
15634 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15635 int result;
15636 PyObject * obj0 = 0 ;
15637 char *kwnames[] = {
15638 (char *) "self", NULL
15639 };
15640
15641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15643 if (SWIG_arg_fail(1)) SWIG_fail;
15644 {
15645 PyThreadState* __tstate = wxPyBeginAllowThreads();
15646 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15647
15648 wxPyEndAllowThreads(__tstate);
15649 if (PyErr_Occurred()) SWIG_fail;
15650 }
15651 {
15652 resultobj = SWIG_From_int((int)(result));
15653 }
15654 return resultobj;
15655 fail:
15656 return NULL;
15657 }
15658
15659
15660 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15661 PyObject *resultobj;
15662 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15663 int arg2 ;
15664 PyObject * obj0 = 0 ;
15665 PyObject * obj1 = 0 ;
15666 char *kwnames[] = {
15667 (char *) "self",(char *) "orient", NULL
15668 };
15669
15670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15672 if (SWIG_arg_fail(1)) SWIG_fail;
15673 {
15674 arg2 = (int)(SWIG_As_int(obj1));
15675 if (SWIG_arg_fail(2)) SWIG_fail;
15676 }
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 (arg1)->SetOrientation(arg2);
15680
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 Py_INCREF(Py_None); resultobj = Py_None;
15685 return resultobj;
15686 fail:
15687 return NULL;
15688 }
15689
15690
15691 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15692 PyObject *resultobj;
15693 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15694 int arg2 ;
15695 PyObject * obj0 = 0 ;
15696 PyObject * obj1 = 0 ;
15697 char *kwnames[] = {
15698 (char *) "self",(char *) "pos", NULL
15699 };
15700
15701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15703 if (SWIG_arg_fail(1)) SWIG_fail;
15704 {
15705 arg2 = (int)(SWIG_As_int(obj1));
15706 if (SWIG_arg_fail(2)) SWIG_fail;
15707 }
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 (arg1)->SetPosition(arg2);
15711
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 Py_INCREF(Py_None); resultobj = Py_None;
15716 return resultobj;
15717 fail:
15718 return NULL;
15719 }
15720
15721
15722 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15723 PyObject *obj;
15724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15725 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15726 Py_INCREF(obj);
15727 return Py_BuildValue((char *)"");
15728 }
15729 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15730 PyObject *resultobj;
15731 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15732 int arg2 = (int) 0 ;
15733 int arg3 = (int) 0 ;
15734 wxScrollWinEvent *result;
15735 PyObject * obj0 = 0 ;
15736 PyObject * obj1 = 0 ;
15737 PyObject * obj2 = 0 ;
15738 char *kwnames[] = {
15739 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15740 };
15741
15742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15743 if (obj0) {
15744 {
15745 arg1 = (wxEventType)(SWIG_As_int(obj0));
15746 if (SWIG_arg_fail(1)) SWIG_fail;
15747 }
15748 }
15749 if (obj1) {
15750 {
15751 arg2 = (int)(SWIG_As_int(obj1));
15752 if (SWIG_arg_fail(2)) SWIG_fail;
15753 }
15754 }
15755 if (obj2) {
15756 {
15757 arg3 = (int)(SWIG_As_int(obj2));
15758 if (SWIG_arg_fail(3)) SWIG_fail;
15759 }
15760 }
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15764
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15769 return resultobj;
15770 fail:
15771 return NULL;
15772 }
15773
15774
15775 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj;
15777 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15778 int result;
15779 PyObject * obj0 = 0 ;
15780 char *kwnames[] = {
15781 (char *) "self", NULL
15782 };
15783
15784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15786 if (SWIG_arg_fail(1)) SWIG_fail;
15787 {
15788 PyThreadState* __tstate = wxPyBeginAllowThreads();
15789 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15790
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 {
15795 resultobj = SWIG_From_int((int)(result));
15796 }
15797 return resultobj;
15798 fail:
15799 return NULL;
15800 }
15801
15802
15803 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15804 PyObject *resultobj;
15805 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15806 int result;
15807 PyObject * obj0 = 0 ;
15808 char *kwnames[] = {
15809 (char *) "self", NULL
15810 };
15811
15812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15814 if (SWIG_arg_fail(1)) SWIG_fail;
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15818
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 {
15823 resultobj = SWIG_From_int((int)(result));
15824 }
15825 return resultobj;
15826 fail:
15827 return NULL;
15828 }
15829
15830
15831 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj;
15833 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15834 int arg2 ;
15835 PyObject * obj0 = 0 ;
15836 PyObject * obj1 = 0 ;
15837 char *kwnames[] = {
15838 (char *) "self",(char *) "orient", NULL
15839 };
15840
15841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15843 if (SWIG_arg_fail(1)) SWIG_fail;
15844 {
15845 arg2 = (int)(SWIG_As_int(obj1));
15846 if (SWIG_arg_fail(2)) SWIG_fail;
15847 }
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 (arg1)->SetOrientation(arg2);
15851
15852 wxPyEndAllowThreads(__tstate);
15853 if (PyErr_Occurred()) SWIG_fail;
15854 }
15855 Py_INCREF(Py_None); resultobj = Py_None;
15856 return resultobj;
15857 fail:
15858 return NULL;
15859 }
15860
15861
15862 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj;
15864 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15865 int arg2 ;
15866 PyObject * obj0 = 0 ;
15867 PyObject * obj1 = 0 ;
15868 char *kwnames[] = {
15869 (char *) "self",(char *) "pos", NULL
15870 };
15871
15872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15874 if (SWIG_arg_fail(1)) SWIG_fail;
15875 {
15876 arg2 = (int)(SWIG_As_int(obj1));
15877 if (SWIG_arg_fail(2)) SWIG_fail;
15878 }
15879 {
15880 PyThreadState* __tstate = wxPyBeginAllowThreads();
15881 (arg1)->SetPosition(arg2);
15882
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 Py_INCREF(Py_None); resultobj = Py_None;
15887 return resultobj;
15888 fail:
15889 return NULL;
15890 }
15891
15892
15893 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15894 PyObject *obj;
15895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15896 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15897 Py_INCREF(obj);
15898 return Py_BuildValue((char *)"");
15899 }
15900 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj;
15902 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15903 wxMouseEvent *result;
15904 PyObject * obj0 = 0 ;
15905 char *kwnames[] = {
15906 (char *) "mouseType", NULL
15907 };
15908
15909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15910 if (obj0) {
15911 {
15912 arg1 = (wxEventType)(SWIG_As_int(obj0));
15913 if (SWIG_arg_fail(1)) SWIG_fail;
15914 }
15915 }
15916 {
15917 PyThreadState* __tstate = wxPyBeginAllowThreads();
15918 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15919
15920 wxPyEndAllowThreads(__tstate);
15921 if (PyErr_Occurred()) SWIG_fail;
15922 }
15923 {
15924 resultobj = wxPyMake_wxObject(result, 1);
15925 }
15926 return resultobj;
15927 fail:
15928 return NULL;
15929 }
15930
15931
15932 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15933 PyObject *resultobj;
15934 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15935 bool result;
15936 PyObject * obj0 = 0 ;
15937 char *kwnames[] = {
15938 (char *) "self", NULL
15939 };
15940
15941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15943 if (SWIG_arg_fail(1)) SWIG_fail;
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15947
15948 wxPyEndAllowThreads(__tstate);
15949 if (PyErr_Occurred()) SWIG_fail;
15950 }
15951 {
15952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15953 }
15954 return resultobj;
15955 fail:
15956 return NULL;
15957 }
15958
15959
15960 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15961 PyObject *resultobj;
15962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15963 int arg2 = (int) wxMOUSE_BTN_ANY ;
15964 bool result;
15965 PyObject * obj0 = 0 ;
15966 PyObject * obj1 = 0 ;
15967 char *kwnames[] = {
15968 (char *) "self",(char *) "but", NULL
15969 };
15970
15971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15973 if (SWIG_arg_fail(1)) SWIG_fail;
15974 if (obj1) {
15975 {
15976 arg2 = (int)(SWIG_As_int(obj1));
15977 if (SWIG_arg_fail(2)) SWIG_fail;
15978 }
15979 }
15980 {
15981 PyThreadState* __tstate = wxPyBeginAllowThreads();
15982 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15983
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 {
15988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15989 }
15990 return resultobj;
15991 fail:
15992 return NULL;
15993 }
15994
15995
15996 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15997 PyObject *resultobj;
15998 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15999 int arg2 = (int) wxMOUSE_BTN_ANY ;
16000 bool result;
16001 PyObject * obj0 = 0 ;
16002 PyObject * obj1 = 0 ;
16003 char *kwnames[] = {
16004 (char *) "self",(char *) "but", NULL
16005 };
16006
16007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16009 if (SWIG_arg_fail(1)) SWIG_fail;
16010 if (obj1) {
16011 {
16012 arg2 = (int)(SWIG_As_int(obj1));
16013 if (SWIG_arg_fail(2)) SWIG_fail;
16014 }
16015 }
16016 {
16017 PyThreadState* __tstate = wxPyBeginAllowThreads();
16018 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16019
16020 wxPyEndAllowThreads(__tstate);
16021 if (PyErr_Occurred()) SWIG_fail;
16022 }
16023 {
16024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16025 }
16026 return resultobj;
16027 fail:
16028 return NULL;
16029 }
16030
16031
16032 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16033 PyObject *resultobj;
16034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16035 int arg2 = (int) wxMOUSE_BTN_ANY ;
16036 bool result;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char *kwnames[] = {
16040 (char *) "self",(char *) "but", NULL
16041 };
16042
16043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16045 if (SWIG_arg_fail(1)) SWIG_fail;
16046 if (obj1) {
16047 {
16048 arg2 = (int)(SWIG_As_int(obj1));
16049 if (SWIG_arg_fail(2)) SWIG_fail;
16050 }
16051 }
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16055
16056 wxPyEndAllowThreads(__tstate);
16057 if (PyErr_Occurred()) SWIG_fail;
16058 }
16059 {
16060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16061 }
16062 return resultobj;
16063 fail:
16064 return NULL;
16065 }
16066
16067
16068 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16069 PyObject *resultobj;
16070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16071 int arg2 ;
16072 bool result;
16073 PyObject * obj0 = 0 ;
16074 PyObject * obj1 = 0 ;
16075 char *kwnames[] = {
16076 (char *) "self",(char *) "but", NULL
16077 };
16078
16079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16081 if (SWIG_arg_fail(1)) SWIG_fail;
16082 {
16083 arg2 = (int)(SWIG_As_int(obj1));
16084 if (SWIG_arg_fail(2)) SWIG_fail;
16085 }
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16089
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 {
16094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16095 }
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16103 PyObject *resultobj;
16104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16105 int arg2 ;
16106 bool result;
16107 PyObject * obj0 = 0 ;
16108 PyObject * obj1 = 0 ;
16109 char *kwnames[] = {
16110 (char *) "self",(char *) "but", NULL
16111 };
16112
16113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16115 if (SWIG_arg_fail(1)) SWIG_fail;
16116 {
16117 arg2 = (int)(SWIG_As_int(obj1));
16118 if (SWIG_arg_fail(2)) SWIG_fail;
16119 }
16120 {
16121 PyThreadState* __tstate = wxPyBeginAllowThreads();
16122 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16123
16124 wxPyEndAllowThreads(__tstate);
16125 if (PyErr_Occurred()) SWIG_fail;
16126 }
16127 {
16128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16129 }
16130 return resultobj;
16131 fail:
16132 return NULL;
16133 }
16134
16135
16136 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16137 PyObject *resultobj;
16138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16139 int result;
16140 PyObject * obj0 = 0 ;
16141 char *kwnames[] = {
16142 (char *) "self", NULL
16143 };
16144
16145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16147 if (SWIG_arg_fail(1)) SWIG_fail;
16148 {
16149 PyThreadState* __tstate = wxPyBeginAllowThreads();
16150 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16151
16152 wxPyEndAllowThreads(__tstate);
16153 if (PyErr_Occurred()) SWIG_fail;
16154 }
16155 {
16156 resultobj = SWIG_From_int((int)(result));
16157 }
16158 return resultobj;
16159 fail:
16160 return NULL;
16161 }
16162
16163
16164 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16165 PyObject *resultobj;
16166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16167 bool result;
16168 PyObject * obj0 = 0 ;
16169 char *kwnames[] = {
16170 (char *) "self", NULL
16171 };
16172
16173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16175 if (SWIG_arg_fail(1)) SWIG_fail;
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16179
16180 wxPyEndAllowThreads(__tstate);
16181 if (PyErr_Occurred()) SWIG_fail;
16182 }
16183 {
16184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16185 }
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj;
16194 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16195 bool result;
16196 PyObject * obj0 = 0 ;
16197 char *kwnames[] = {
16198 (char *) "self", NULL
16199 };
16200
16201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16203 if (SWIG_arg_fail(1)) SWIG_fail;
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16207
16208 wxPyEndAllowThreads(__tstate);
16209 if (PyErr_Occurred()) SWIG_fail;
16210 }
16211 {
16212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16213 }
16214 return resultobj;
16215 fail:
16216 return NULL;
16217 }
16218
16219
16220 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16221 PyObject *resultobj;
16222 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16223 bool result;
16224 PyObject * obj0 = 0 ;
16225 char *kwnames[] = {
16226 (char *) "self", NULL
16227 };
16228
16229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16231 if (SWIG_arg_fail(1)) SWIG_fail;
16232 {
16233 PyThreadState* __tstate = wxPyBeginAllowThreads();
16234 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16235
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 {
16240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16241 }
16242 return resultobj;
16243 fail:
16244 return NULL;
16245 }
16246
16247
16248 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16249 PyObject *resultobj;
16250 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16251 bool result;
16252 PyObject * obj0 = 0 ;
16253 char *kwnames[] = {
16254 (char *) "self", NULL
16255 };
16256
16257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16259 if (SWIG_arg_fail(1)) SWIG_fail;
16260 {
16261 PyThreadState* __tstate = wxPyBeginAllowThreads();
16262 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16263
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 {
16268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16269 }
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16277 PyObject *resultobj;
16278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16279 bool result;
16280 PyObject * obj0 = 0 ;
16281 char *kwnames[] = {
16282 (char *) "self", NULL
16283 };
16284
16285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16287 if (SWIG_arg_fail(1)) SWIG_fail;
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16291
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 {
16296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16297 }
16298 return resultobj;
16299 fail:
16300 return NULL;
16301 }
16302
16303
16304 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16305 PyObject *resultobj;
16306 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16307 bool result;
16308 PyObject * obj0 = 0 ;
16309 char *kwnames[] = {
16310 (char *) "self", NULL
16311 };
16312
16313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16315 if (SWIG_arg_fail(1)) SWIG_fail;
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16319
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 {
16324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16325 }
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj;
16334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16335 bool result;
16336 PyObject * obj0 = 0 ;
16337 char *kwnames[] = {
16338 (char *) "self", NULL
16339 };
16340
16341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16343 if (SWIG_arg_fail(1)) SWIG_fail;
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16347
16348 wxPyEndAllowThreads(__tstate);
16349 if (PyErr_Occurred()) SWIG_fail;
16350 }
16351 {
16352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16353 }
16354 return resultobj;
16355 fail:
16356 return NULL;
16357 }
16358
16359
16360 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16361 PyObject *resultobj;
16362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16363 bool result;
16364 PyObject * obj0 = 0 ;
16365 char *kwnames[] = {
16366 (char *) "self", NULL
16367 };
16368
16369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16371 if (SWIG_arg_fail(1)) SWIG_fail;
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16375
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 {
16380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16381 }
16382 return resultobj;
16383 fail:
16384 return NULL;
16385 }
16386
16387
16388 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16389 PyObject *resultobj;
16390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16391 bool result;
16392 PyObject * obj0 = 0 ;
16393 char *kwnames[] = {
16394 (char *) "self", NULL
16395 };
16396
16397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16399 if (SWIG_arg_fail(1)) SWIG_fail;
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16403
16404 wxPyEndAllowThreads(__tstate);
16405 if (PyErr_Occurred()) SWIG_fail;
16406 }
16407 {
16408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16409 }
16410 return resultobj;
16411 fail:
16412 return NULL;
16413 }
16414
16415
16416 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16417 PyObject *resultobj;
16418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16419 bool result;
16420 PyObject * obj0 = 0 ;
16421 char *kwnames[] = {
16422 (char *) "self", NULL
16423 };
16424
16425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16427 if (SWIG_arg_fail(1)) SWIG_fail;
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16431
16432 wxPyEndAllowThreads(__tstate);
16433 if (PyErr_Occurred()) SWIG_fail;
16434 }
16435 {
16436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16437 }
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj;
16446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16447 bool result;
16448 PyObject * obj0 = 0 ;
16449 char *kwnames[] = {
16450 (char *) "self", NULL
16451 };
16452
16453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16455 if (SWIG_arg_fail(1)) SWIG_fail;
16456 {
16457 PyThreadState* __tstate = wxPyBeginAllowThreads();
16458 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16459
16460 wxPyEndAllowThreads(__tstate);
16461 if (PyErr_Occurred()) SWIG_fail;
16462 }
16463 {
16464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16465 }
16466 return resultobj;
16467 fail:
16468 return NULL;
16469 }
16470
16471
16472 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj;
16474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16475 bool result;
16476 PyObject * obj0 = 0 ;
16477 char *kwnames[] = {
16478 (char *) "self", NULL
16479 };
16480
16481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16483 if (SWIG_arg_fail(1)) SWIG_fail;
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16487
16488 wxPyEndAllowThreads(__tstate);
16489 if (PyErr_Occurred()) SWIG_fail;
16490 }
16491 {
16492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16493 }
16494 return resultobj;
16495 fail:
16496 return NULL;
16497 }
16498
16499
16500 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16501 PyObject *resultobj;
16502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16503 bool result;
16504 PyObject * obj0 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16515
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 {
16520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16521 }
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj;
16530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16531 bool result;
16532 PyObject * obj0 = 0 ;
16533 char *kwnames[] = {
16534 (char *) "self", NULL
16535 };
16536
16537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16539 if (SWIG_arg_fail(1)) SWIG_fail;
16540 {
16541 PyThreadState* __tstate = wxPyBeginAllowThreads();
16542 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16543
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 {
16548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16549 }
16550 return resultobj;
16551 fail:
16552 return NULL;
16553 }
16554
16555
16556 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16557 PyObject *resultobj;
16558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16559 bool result;
16560 PyObject * obj0 = 0 ;
16561 char *kwnames[] = {
16562 (char *) "self", NULL
16563 };
16564
16565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16567 if (SWIG_arg_fail(1)) SWIG_fail;
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = (bool)(arg1)->LeftIsDown();
16571
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 {
16576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16577 }
16578 return resultobj;
16579 fail:
16580 return NULL;
16581 }
16582
16583
16584 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16585 PyObject *resultobj;
16586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16587 bool result;
16588 PyObject * obj0 = 0 ;
16589 char *kwnames[] = {
16590 (char *) "self", NULL
16591 };
16592
16593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16595 if (SWIG_arg_fail(1)) SWIG_fail;
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = (bool)(arg1)->MiddleIsDown();
16599
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 {
16604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16605 }
16606 return resultobj;
16607 fail:
16608 return NULL;
16609 }
16610
16611
16612 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16613 PyObject *resultobj;
16614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16615 bool result;
16616 PyObject * obj0 = 0 ;
16617 char *kwnames[] = {
16618 (char *) "self", NULL
16619 };
16620
16621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16623 if (SWIG_arg_fail(1)) SWIG_fail;
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = (bool)(arg1)->RightIsDown();
16627
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 {
16632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16633 }
16634 return resultobj;
16635 fail:
16636 return NULL;
16637 }
16638
16639
16640 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16641 PyObject *resultobj;
16642 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16643 bool result;
16644 PyObject * obj0 = 0 ;
16645 char *kwnames[] = {
16646 (char *) "self", NULL
16647 };
16648
16649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16651 if (SWIG_arg_fail(1)) SWIG_fail;
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16655
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 {
16660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16661 }
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16671 bool result;
16672 PyObject * obj0 = 0 ;
16673 char *kwnames[] = {
16674 (char *) "self", NULL
16675 };
16676
16677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16679 if (SWIG_arg_fail(1)) SWIG_fail;
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16683
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 {
16688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16689 }
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj;
16698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16699 bool result;
16700 PyObject * obj0 = 0 ;
16701 char *kwnames[] = {
16702 (char *) "self", NULL
16703 };
16704
16705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16707 if (SWIG_arg_fail(1)) SWIG_fail;
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 {
16716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16717 }
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16727 bool result;
16728 PyObject * obj0 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16735 if (SWIG_arg_fail(1)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16739
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 {
16744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16745 }
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16755 wxPoint result;
16756 PyObject * obj0 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "self", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16763 if (SWIG_arg_fail(1)) SWIG_fail;
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 result = (arg1)->GetPosition();
16767
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 {
16772 wxPoint * resultptr;
16773 resultptr = new wxPoint((wxPoint &)(result));
16774 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16775 }
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj;
16784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16785 long *arg2 = (long *) 0 ;
16786 long *arg3 = (long *) 0 ;
16787 long temp2 ;
16788 int res2 = 0 ;
16789 long temp3 ;
16790 int res3 = 0 ;
16791 PyObject * obj0 = 0 ;
16792 char *kwnames[] = {
16793 (char *) "self", NULL
16794 };
16795
16796 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16797 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16800 if (SWIG_arg_fail(1)) SWIG_fail;
16801 {
16802 PyThreadState* __tstate = wxPyBeginAllowThreads();
16803 (arg1)->GetPosition(arg2,arg3);
16804
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 Py_INCREF(Py_None); resultobj = Py_None;
16809 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16810 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16811 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16812 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj;
16821 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16822 wxDC *arg2 = 0 ;
16823 wxPoint result;
16824 PyObject * obj0 = 0 ;
16825 PyObject * obj1 = 0 ;
16826 char *kwnames[] = {
16827 (char *) "self",(char *) "dc", NULL
16828 };
16829
16830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16832 if (SWIG_arg_fail(1)) SWIG_fail;
16833 {
16834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16835 if (SWIG_arg_fail(2)) SWIG_fail;
16836 if (arg2 == NULL) {
16837 SWIG_null_ref("wxDC");
16838 }
16839 if (SWIG_arg_fail(2)) SWIG_fail;
16840 }
16841 {
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16844
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 {
16849 wxPoint * resultptr;
16850 resultptr = new wxPoint((wxPoint &)(result));
16851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16852 }
16853 return resultobj;
16854 fail:
16855 return NULL;
16856 }
16857
16858
16859 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16860 PyObject *resultobj;
16861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16862 int result;
16863 PyObject * obj0 = 0 ;
16864 char *kwnames[] = {
16865 (char *) "self", NULL
16866 };
16867
16868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16870 if (SWIG_arg_fail(1)) SWIG_fail;
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = (int)((wxMouseEvent const *)arg1)->GetX();
16874
16875 wxPyEndAllowThreads(__tstate);
16876 if (PyErr_Occurred()) SWIG_fail;
16877 }
16878 {
16879 resultobj = SWIG_From_int((int)(result));
16880 }
16881 return resultobj;
16882 fail:
16883 return NULL;
16884 }
16885
16886
16887 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16888 PyObject *resultobj;
16889 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16890 int result;
16891 PyObject * obj0 = 0 ;
16892 char *kwnames[] = {
16893 (char *) "self", NULL
16894 };
16895
16896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16898 if (SWIG_arg_fail(1)) SWIG_fail;
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 result = (int)((wxMouseEvent const *)arg1)->GetY();
16902
16903 wxPyEndAllowThreads(__tstate);
16904 if (PyErr_Occurred()) SWIG_fail;
16905 }
16906 {
16907 resultobj = SWIG_From_int((int)(result));
16908 }
16909 return resultobj;
16910 fail:
16911 return NULL;
16912 }
16913
16914
16915 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj;
16917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16918 int result;
16919 PyObject * obj0 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 {
16928 PyThreadState* __tstate = wxPyBeginAllowThreads();
16929 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16930
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 {
16935 resultobj = SWIG_From_int((int)(result));
16936 }
16937 return resultobj;
16938 fail:
16939 return NULL;
16940 }
16941
16942
16943 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16944 PyObject *resultobj;
16945 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16946 int result;
16947 PyObject * obj0 = 0 ;
16948 char *kwnames[] = {
16949 (char *) "self", NULL
16950 };
16951
16952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16954 if (SWIG_arg_fail(1)) SWIG_fail;
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16958
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 {
16963 resultobj = SWIG_From_int((int)(result));
16964 }
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16972 PyObject *resultobj;
16973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16974 int result;
16975 PyObject * obj0 = 0 ;
16976 char *kwnames[] = {
16977 (char *) "self", NULL
16978 };
16979
16980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16982 if (SWIG_arg_fail(1)) SWIG_fail;
16983 {
16984 PyThreadState* __tstate = wxPyBeginAllowThreads();
16985 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16986
16987 wxPyEndAllowThreads(__tstate);
16988 if (PyErr_Occurred()) SWIG_fail;
16989 }
16990 {
16991 resultobj = SWIG_From_int((int)(result));
16992 }
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17000 PyObject *resultobj;
17001 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17002 bool result;
17003 PyObject * obj0 = 0 ;
17004 char *kwnames[] = {
17005 (char *) "self", NULL
17006 };
17007
17008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17010 if (SWIG_arg_fail(1)) SWIG_fail;
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17014
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 {
17019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17020 }
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj;
17029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17030 int arg2 ;
17031 PyObject * obj0 = 0 ;
17032 PyObject * obj1 = 0 ;
17033 char *kwnames[] = {
17034 (char *) "self",(char *) "m_x", NULL
17035 };
17036
17037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17039 if (SWIG_arg_fail(1)) SWIG_fail;
17040 {
17041 arg2 = (int)(SWIG_As_int(obj1));
17042 if (SWIG_arg_fail(2)) SWIG_fail;
17043 }
17044 if (arg1) (arg1)->m_x = arg2;
17045
17046 Py_INCREF(Py_None); resultobj = Py_None;
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17054 PyObject *resultobj;
17055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17056 int result;
17057 PyObject * obj0 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 result = (int) ((arg1)->m_x);
17066
17067 {
17068 resultobj = SWIG_From_int((int)(result));
17069 }
17070 return resultobj;
17071 fail:
17072 return NULL;
17073 }
17074
17075
17076 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17077 PyObject *resultobj;
17078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17079 int arg2 ;
17080 PyObject * obj0 = 0 ;
17081 PyObject * obj1 = 0 ;
17082 char *kwnames[] = {
17083 (char *) "self",(char *) "m_y", NULL
17084 };
17085
17086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17088 if (SWIG_arg_fail(1)) SWIG_fail;
17089 {
17090 arg2 = (int)(SWIG_As_int(obj1));
17091 if (SWIG_arg_fail(2)) SWIG_fail;
17092 }
17093 if (arg1) (arg1)->m_y = arg2;
17094
17095 Py_INCREF(Py_None); resultobj = Py_None;
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj;
17104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17105 int result;
17106 PyObject * obj0 = 0 ;
17107 char *kwnames[] = {
17108 (char *) "self", NULL
17109 };
17110
17111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17113 if (SWIG_arg_fail(1)) SWIG_fail;
17114 result = (int) ((arg1)->m_y);
17115
17116 {
17117 resultobj = SWIG_From_int((int)(result));
17118 }
17119 return resultobj;
17120 fail:
17121 return NULL;
17122 }
17123
17124
17125 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17126 PyObject *resultobj;
17127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17128 bool arg2 ;
17129 PyObject * obj0 = 0 ;
17130 PyObject * obj1 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self",(char *) "m_leftDown", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 {
17139 arg2 = (bool)(SWIG_As_bool(obj1));
17140 if (SWIG_arg_fail(2)) SWIG_fail;
17141 }
17142 if (arg1) (arg1)->m_leftDown = arg2;
17143
17144 Py_INCREF(Py_None); resultobj = Py_None;
17145 return resultobj;
17146 fail:
17147 return NULL;
17148 }
17149
17150
17151 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17152 PyObject *resultobj;
17153 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17154 bool result;
17155 PyObject * obj0 = 0 ;
17156 char *kwnames[] = {
17157 (char *) "self", NULL
17158 };
17159
17160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17162 if (SWIG_arg_fail(1)) SWIG_fail;
17163 result = (bool) ((arg1)->m_leftDown);
17164
17165 {
17166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17167 }
17168 return resultobj;
17169 fail:
17170 return NULL;
17171 }
17172
17173
17174 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17175 PyObject *resultobj;
17176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17177 bool arg2 ;
17178 PyObject * obj0 = 0 ;
17179 PyObject * obj1 = 0 ;
17180 char *kwnames[] = {
17181 (char *) "self",(char *) "m_middleDown", NULL
17182 };
17183
17184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17186 if (SWIG_arg_fail(1)) SWIG_fail;
17187 {
17188 arg2 = (bool)(SWIG_As_bool(obj1));
17189 if (SWIG_arg_fail(2)) SWIG_fail;
17190 }
17191 if (arg1) (arg1)->m_middleDown = arg2;
17192
17193 Py_INCREF(Py_None); resultobj = Py_None;
17194 return resultobj;
17195 fail:
17196 return NULL;
17197 }
17198
17199
17200 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17201 PyObject *resultobj;
17202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17203 bool result;
17204 PyObject * obj0 = 0 ;
17205 char *kwnames[] = {
17206 (char *) "self", NULL
17207 };
17208
17209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17211 if (SWIG_arg_fail(1)) SWIG_fail;
17212 result = (bool) ((arg1)->m_middleDown);
17213
17214 {
17215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17216 }
17217 return resultobj;
17218 fail:
17219 return NULL;
17220 }
17221
17222
17223 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17224 PyObject *resultobj;
17225 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17226 bool arg2 ;
17227 PyObject * obj0 = 0 ;
17228 PyObject * obj1 = 0 ;
17229 char *kwnames[] = {
17230 (char *) "self",(char *) "m_rightDown", NULL
17231 };
17232
17233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17235 if (SWIG_arg_fail(1)) SWIG_fail;
17236 {
17237 arg2 = (bool)(SWIG_As_bool(obj1));
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 }
17240 if (arg1) (arg1)->m_rightDown = arg2;
17241
17242 Py_INCREF(Py_None); resultobj = Py_None;
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj;
17251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17252 bool result;
17253 PyObject * obj0 = 0 ;
17254 char *kwnames[] = {
17255 (char *) "self", NULL
17256 };
17257
17258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17260 if (SWIG_arg_fail(1)) SWIG_fail;
17261 result = (bool) ((arg1)->m_rightDown);
17262
17263 {
17264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17265 }
17266 return resultobj;
17267 fail:
17268 return NULL;
17269 }
17270
17271
17272 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17273 PyObject *resultobj;
17274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17275 bool arg2 ;
17276 PyObject * obj0 = 0 ;
17277 PyObject * obj1 = 0 ;
17278 char *kwnames[] = {
17279 (char *) "self",(char *) "m_controlDown", NULL
17280 };
17281
17282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17284 if (SWIG_arg_fail(1)) SWIG_fail;
17285 {
17286 arg2 = (bool)(SWIG_As_bool(obj1));
17287 if (SWIG_arg_fail(2)) SWIG_fail;
17288 }
17289 if (arg1) (arg1)->m_controlDown = arg2;
17290
17291 Py_INCREF(Py_None); resultobj = Py_None;
17292 return resultobj;
17293 fail:
17294 return NULL;
17295 }
17296
17297
17298 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj;
17300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17301 bool result;
17302 PyObject * obj0 = 0 ;
17303 char *kwnames[] = {
17304 (char *) "self", NULL
17305 };
17306
17307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17309 if (SWIG_arg_fail(1)) SWIG_fail;
17310 result = (bool) ((arg1)->m_controlDown);
17311
17312 {
17313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17314 }
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17322 PyObject *resultobj;
17323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17324 bool arg2 ;
17325 PyObject * obj0 = 0 ;
17326 PyObject * obj1 = 0 ;
17327 char *kwnames[] = {
17328 (char *) "self",(char *) "m_shiftDown", NULL
17329 };
17330
17331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17333 if (SWIG_arg_fail(1)) SWIG_fail;
17334 {
17335 arg2 = (bool)(SWIG_As_bool(obj1));
17336 if (SWIG_arg_fail(2)) SWIG_fail;
17337 }
17338 if (arg1) (arg1)->m_shiftDown = arg2;
17339
17340 Py_INCREF(Py_None); resultobj = Py_None;
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj;
17349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17350 bool result;
17351 PyObject * obj0 = 0 ;
17352 char *kwnames[] = {
17353 (char *) "self", NULL
17354 };
17355
17356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17358 if (SWIG_arg_fail(1)) SWIG_fail;
17359 result = (bool) ((arg1)->m_shiftDown);
17360
17361 {
17362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17363 }
17364 return resultobj;
17365 fail:
17366 return NULL;
17367 }
17368
17369
17370 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17371 PyObject *resultobj;
17372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17373 bool arg2 ;
17374 PyObject * obj0 = 0 ;
17375 PyObject * obj1 = 0 ;
17376 char *kwnames[] = {
17377 (char *) "self",(char *) "m_altDown", NULL
17378 };
17379
17380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17382 if (SWIG_arg_fail(1)) SWIG_fail;
17383 {
17384 arg2 = (bool)(SWIG_As_bool(obj1));
17385 if (SWIG_arg_fail(2)) SWIG_fail;
17386 }
17387 if (arg1) (arg1)->m_altDown = arg2;
17388
17389 Py_INCREF(Py_None); resultobj = Py_None;
17390 return resultobj;
17391 fail:
17392 return NULL;
17393 }
17394
17395
17396 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17397 PyObject *resultobj;
17398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17399 bool result;
17400 PyObject * obj0 = 0 ;
17401 char *kwnames[] = {
17402 (char *) "self", NULL
17403 };
17404
17405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17407 if (SWIG_arg_fail(1)) SWIG_fail;
17408 result = (bool) ((arg1)->m_altDown);
17409
17410 {
17411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17412 }
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17420 PyObject *resultobj;
17421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17422 bool arg2 ;
17423 PyObject * obj0 = 0 ;
17424 PyObject * obj1 = 0 ;
17425 char *kwnames[] = {
17426 (char *) "self",(char *) "m_metaDown", NULL
17427 };
17428
17429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17431 if (SWIG_arg_fail(1)) SWIG_fail;
17432 {
17433 arg2 = (bool)(SWIG_As_bool(obj1));
17434 if (SWIG_arg_fail(2)) SWIG_fail;
17435 }
17436 if (arg1) (arg1)->m_metaDown = arg2;
17437
17438 Py_INCREF(Py_None); resultobj = Py_None;
17439 return resultobj;
17440 fail:
17441 return NULL;
17442 }
17443
17444
17445 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17446 PyObject *resultobj;
17447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17448 bool result;
17449 PyObject * obj0 = 0 ;
17450 char *kwnames[] = {
17451 (char *) "self", NULL
17452 };
17453
17454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17456 if (SWIG_arg_fail(1)) SWIG_fail;
17457 result = (bool) ((arg1)->m_metaDown);
17458
17459 {
17460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17461 }
17462 return resultobj;
17463 fail:
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj;
17470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17471 int arg2 ;
17472 PyObject * obj0 = 0 ;
17473 PyObject * obj1 = 0 ;
17474 char *kwnames[] = {
17475 (char *) "self",(char *) "m_wheelRotation", NULL
17476 };
17477
17478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17480 if (SWIG_arg_fail(1)) SWIG_fail;
17481 {
17482 arg2 = (int)(SWIG_As_int(obj1));
17483 if (SWIG_arg_fail(2)) SWIG_fail;
17484 }
17485 if (arg1) (arg1)->m_wheelRotation = arg2;
17486
17487 Py_INCREF(Py_None); resultobj = Py_None;
17488 return resultobj;
17489 fail:
17490 return NULL;
17491 }
17492
17493
17494 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj;
17496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17497 int result;
17498 PyObject * obj0 = 0 ;
17499 char *kwnames[] = {
17500 (char *) "self", NULL
17501 };
17502
17503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17505 if (SWIG_arg_fail(1)) SWIG_fail;
17506 result = (int) ((arg1)->m_wheelRotation);
17507
17508 {
17509 resultobj = SWIG_From_int((int)(result));
17510 }
17511 return resultobj;
17512 fail:
17513 return NULL;
17514 }
17515
17516
17517 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17518 PyObject *resultobj;
17519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17520 int arg2 ;
17521 PyObject * obj0 = 0 ;
17522 PyObject * obj1 = 0 ;
17523 char *kwnames[] = {
17524 (char *) "self",(char *) "m_wheelDelta", NULL
17525 };
17526
17527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17529 if (SWIG_arg_fail(1)) SWIG_fail;
17530 {
17531 arg2 = (int)(SWIG_As_int(obj1));
17532 if (SWIG_arg_fail(2)) SWIG_fail;
17533 }
17534 if (arg1) (arg1)->m_wheelDelta = arg2;
17535
17536 Py_INCREF(Py_None); resultobj = Py_None;
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17544 PyObject *resultobj;
17545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17546 int result;
17547 PyObject * obj0 = 0 ;
17548 char *kwnames[] = {
17549 (char *) "self", NULL
17550 };
17551
17552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17554 if (SWIG_arg_fail(1)) SWIG_fail;
17555 result = (int) ((arg1)->m_wheelDelta);
17556
17557 {
17558 resultobj = SWIG_From_int((int)(result));
17559 }
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17567 PyObject *resultobj;
17568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17569 int arg2 ;
17570 PyObject * obj0 = 0 ;
17571 PyObject * obj1 = 0 ;
17572 char *kwnames[] = {
17573 (char *) "self",(char *) "m_linesPerAction", NULL
17574 };
17575
17576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17578 if (SWIG_arg_fail(1)) SWIG_fail;
17579 {
17580 arg2 = (int)(SWIG_As_int(obj1));
17581 if (SWIG_arg_fail(2)) SWIG_fail;
17582 }
17583 if (arg1) (arg1)->m_linesPerAction = arg2;
17584
17585 Py_INCREF(Py_None); resultobj = Py_None;
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17595 int result;
17596 PyObject * obj0 = 0 ;
17597 char *kwnames[] = {
17598 (char *) "self", NULL
17599 };
17600
17601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17603 if (SWIG_arg_fail(1)) SWIG_fail;
17604 result = (int) ((arg1)->m_linesPerAction);
17605
17606 {
17607 resultobj = SWIG_From_int((int)(result));
17608 }
17609 return resultobj;
17610 fail:
17611 return NULL;
17612 }
17613
17614
17615 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17616 PyObject *obj;
17617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17618 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17619 Py_INCREF(obj);
17620 return Py_BuildValue((char *)"");
17621 }
17622 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj;
17624 int arg1 = (int) 0 ;
17625 int arg2 = (int) 0 ;
17626 wxSetCursorEvent *result;
17627 PyObject * obj0 = 0 ;
17628 PyObject * obj1 = 0 ;
17629 char *kwnames[] = {
17630 (char *) "x",(char *) "y", NULL
17631 };
17632
17633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17634 if (obj0) {
17635 {
17636 arg1 = (int)(SWIG_As_int(obj0));
17637 if (SWIG_arg_fail(1)) SWIG_fail;
17638 }
17639 }
17640 if (obj1) {
17641 {
17642 arg2 = (int)(SWIG_As_int(obj1));
17643 if (SWIG_arg_fail(2)) SWIG_fail;
17644 }
17645 }
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17649
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17654 return resultobj;
17655 fail:
17656 return NULL;
17657 }
17658
17659
17660 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17661 PyObject *resultobj;
17662 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17663 int result;
17664 PyObject * obj0 = 0 ;
17665 char *kwnames[] = {
17666 (char *) "self", NULL
17667 };
17668
17669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17671 if (SWIG_arg_fail(1)) SWIG_fail;
17672 {
17673 PyThreadState* __tstate = wxPyBeginAllowThreads();
17674 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17675
17676 wxPyEndAllowThreads(__tstate);
17677 if (PyErr_Occurred()) SWIG_fail;
17678 }
17679 {
17680 resultobj = SWIG_From_int((int)(result));
17681 }
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj;
17690 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17691 int result;
17692 PyObject * obj0 = 0 ;
17693 char *kwnames[] = {
17694 (char *) "self", NULL
17695 };
17696
17697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17699 if (SWIG_arg_fail(1)) SWIG_fail;
17700 {
17701 PyThreadState* __tstate = wxPyBeginAllowThreads();
17702 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17703
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 {
17708 resultobj = SWIG_From_int((int)(result));
17709 }
17710 return resultobj;
17711 fail:
17712 return NULL;
17713 }
17714
17715
17716 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17717 PyObject *resultobj;
17718 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17719 wxCursor *arg2 = 0 ;
17720 PyObject * obj0 = 0 ;
17721 PyObject * obj1 = 0 ;
17722 char *kwnames[] = {
17723 (char *) "self",(char *) "cursor", NULL
17724 };
17725
17726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17728 if (SWIG_arg_fail(1)) SWIG_fail;
17729 {
17730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(2)) SWIG_fail;
17732 if (arg2 == NULL) {
17733 SWIG_null_ref("wxCursor");
17734 }
17735 if (SWIG_arg_fail(2)) SWIG_fail;
17736 }
17737 {
17738 PyThreadState* __tstate = wxPyBeginAllowThreads();
17739 (arg1)->SetCursor((wxCursor const &)*arg2);
17740
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 Py_INCREF(Py_None); resultobj = Py_None;
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17754 wxCursor *result;
17755 PyObject * obj0 = 0 ;
17756 char *kwnames[] = {
17757 (char *) "self", NULL
17758 };
17759
17760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17762 if (SWIG_arg_fail(1)) SWIG_fail;
17763 {
17764 PyThreadState* __tstate = wxPyBeginAllowThreads();
17765 {
17766 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17767 result = (wxCursor *) &_result_ref;
17768 }
17769
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 {
17774 wxCursor* resultptr = new wxCursor(*result);
17775 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17776 }
17777 return resultobj;
17778 fail:
17779 return NULL;
17780 }
17781
17782
17783 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17784 PyObject *resultobj;
17785 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17786 bool result;
17787 PyObject * obj0 = 0 ;
17788 char *kwnames[] = {
17789 (char *) "self", NULL
17790 };
17791
17792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17794 if (SWIG_arg_fail(1)) SWIG_fail;
17795 {
17796 PyThreadState* __tstate = wxPyBeginAllowThreads();
17797 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17798
17799 wxPyEndAllowThreads(__tstate);
17800 if (PyErr_Occurred()) SWIG_fail;
17801 }
17802 {
17803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17804 }
17805 return resultobj;
17806 fail:
17807 return NULL;
17808 }
17809
17810
17811 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17812 PyObject *obj;
17813 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17814 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17815 Py_INCREF(obj);
17816 return Py_BuildValue((char *)"");
17817 }
17818 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17821 wxKeyEvent *result;
17822 PyObject * obj0 = 0 ;
17823 char *kwnames[] = {
17824 (char *) "keyType", NULL
17825 };
17826
17827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17828 if (obj0) {
17829 {
17830 arg1 = (wxEventType)(SWIG_As_int(obj0));
17831 if (SWIG_arg_fail(1)) SWIG_fail;
17832 }
17833 }
17834 {
17835 PyThreadState* __tstate = wxPyBeginAllowThreads();
17836 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17837
17838 wxPyEndAllowThreads(__tstate);
17839 if (PyErr_Occurred()) SWIG_fail;
17840 }
17841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17842 return resultobj;
17843 fail:
17844 return NULL;
17845 }
17846
17847
17848 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17849 PyObject *resultobj;
17850 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17851 bool result;
17852 PyObject * obj0 = 0 ;
17853 char *kwnames[] = {
17854 (char *) "self", NULL
17855 };
17856
17857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17859 if (SWIG_arg_fail(1)) SWIG_fail;
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17863
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 {
17868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17869 }
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj;
17878 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17879 bool result;
17880 PyObject * obj0 = 0 ;
17881 char *kwnames[] = {
17882 (char *) "self", NULL
17883 };
17884
17885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17887 if (SWIG_arg_fail(1)) SWIG_fail;
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17891
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17897 }
17898 return resultobj;
17899 fail:
17900 return NULL;
17901 }
17902
17903
17904 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17905 PyObject *resultobj;
17906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17907 bool result;
17908 PyObject * obj0 = 0 ;
17909 char *kwnames[] = {
17910 (char *) "self", NULL
17911 };
17912
17913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17915 if (SWIG_arg_fail(1)) SWIG_fail;
17916 {
17917 PyThreadState* __tstate = wxPyBeginAllowThreads();
17918 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17919
17920 wxPyEndAllowThreads(__tstate);
17921 if (PyErr_Occurred()) SWIG_fail;
17922 }
17923 {
17924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17925 }
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17933 PyObject *resultobj;
17934 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17935 bool result;
17936 PyObject * obj0 = 0 ;
17937 char *kwnames[] = {
17938 (char *) "self", NULL
17939 };
17940
17941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17943 if (SWIG_arg_fail(1)) SWIG_fail;
17944 {
17945 PyThreadState* __tstate = wxPyBeginAllowThreads();
17946 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17947
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 {
17952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17953 }
17954 return resultobj;
17955 fail:
17956 return NULL;
17957 }
17958
17959
17960 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj;
17962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17963 bool result;
17964 PyObject * obj0 = 0 ;
17965 char *kwnames[] = {
17966 (char *) "self", NULL
17967 };
17968
17969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17971 if (SWIG_arg_fail(1)) SWIG_fail;
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17975
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 {
17980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17981 }
17982 return resultobj;
17983 fail:
17984 return NULL;
17985 }
17986
17987
17988 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17989 PyObject *resultobj;
17990 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17991 bool result;
17992 PyObject * obj0 = 0 ;
17993 char *kwnames[] = {
17994 (char *) "self", NULL
17995 };
17996
17997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17999 if (SWIG_arg_fail(1)) SWIG_fail;
18000 {
18001 PyThreadState* __tstate = wxPyBeginAllowThreads();
18002 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18003
18004 wxPyEndAllowThreads(__tstate);
18005 if (PyErr_Occurred()) SWIG_fail;
18006 }
18007 {
18008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18009 }
18010 return resultobj;
18011 fail:
18012 return NULL;
18013 }
18014
18015
18016 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18017 PyObject *resultobj;
18018 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18019 int result;
18020 PyObject * obj0 = 0 ;
18021 char *kwnames[] = {
18022 (char *) "self", NULL
18023 };
18024
18025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18027 if (SWIG_arg_fail(1)) SWIG_fail;
18028 {
18029 PyThreadState* __tstate = wxPyBeginAllowThreads();
18030 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18031
18032 wxPyEndAllowThreads(__tstate);
18033 if (PyErr_Occurred()) SWIG_fail;
18034 }
18035 {
18036 resultobj = SWIG_From_int((int)(result));
18037 }
18038 return resultobj;
18039 fail:
18040 return NULL;
18041 }
18042
18043
18044 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18045 PyObject *resultobj;
18046 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18047 int result;
18048 PyObject * obj0 = 0 ;
18049 char *kwnames[] = {
18050 (char *) "self", NULL
18051 };
18052
18053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18055 if (SWIG_arg_fail(1)) SWIG_fail;
18056 {
18057 PyThreadState* __tstate = wxPyBeginAllowThreads();
18058 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18059
18060 wxPyEndAllowThreads(__tstate);
18061 if (PyErr_Occurred()) SWIG_fail;
18062 }
18063 {
18064 resultobj = SWIG_From_int((int)(result));
18065 }
18066 return resultobj;
18067 fail:
18068 return NULL;
18069 }
18070
18071
18072 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18073 PyObject *resultobj;
18074 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18075 unsigned int result;
18076 PyObject * obj0 = 0 ;
18077 char *kwnames[] = {
18078 (char *) "self", NULL
18079 };
18080
18081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18083 if (SWIG_arg_fail(1)) SWIG_fail;
18084 {
18085 PyThreadState* __tstate = wxPyBeginAllowThreads();
18086 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18087
18088 wxPyEndAllowThreads(__tstate);
18089 if (PyErr_Occurred()) SWIG_fail;
18090 }
18091 {
18092 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18093 }
18094 return resultobj;
18095 fail:
18096 return NULL;
18097 }
18098
18099
18100 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18101 PyObject *resultobj;
18102 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18103 unsigned int result;
18104 PyObject * obj0 = 0 ;
18105 char *kwnames[] = {
18106 (char *) "self", NULL
18107 };
18108
18109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18111 if (SWIG_arg_fail(1)) SWIG_fail;
18112 {
18113 PyThreadState* __tstate = wxPyBeginAllowThreads();
18114 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18115
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 {
18120 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18121 }
18122 return resultobj;
18123 fail:
18124 return NULL;
18125 }
18126
18127
18128 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj;
18130 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18131 wxPoint result;
18132 PyObject * obj0 = 0 ;
18133 char *kwnames[] = {
18134 (char *) "self", NULL
18135 };
18136
18137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18139 if (SWIG_arg_fail(1)) SWIG_fail;
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 result = (arg1)->GetPosition();
18143
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 {
18148 wxPoint * resultptr;
18149 resultptr = new wxPoint((wxPoint &)(result));
18150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18151 }
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj;
18160 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18161 long *arg2 = (long *) 0 ;
18162 long *arg3 = (long *) 0 ;
18163 long temp2 ;
18164 int res2 = 0 ;
18165 long temp3 ;
18166 int res3 = 0 ;
18167 PyObject * obj0 = 0 ;
18168 char *kwnames[] = {
18169 (char *) "self", NULL
18170 };
18171
18172 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18173 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 (arg1)->GetPosition(arg2,arg3);
18180
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 Py_INCREF(Py_None); resultobj = Py_None;
18185 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18186 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18187 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18188 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18189 return resultobj;
18190 fail:
18191 return NULL;
18192 }
18193
18194
18195 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18196 PyObject *resultobj;
18197 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18198 int result;
18199 PyObject * obj0 = 0 ;
18200 char *kwnames[] = {
18201 (char *) "self", NULL
18202 };
18203
18204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18206 if (SWIG_arg_fail(1)) SWIG_fail;
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (int)((wxKeyEvent const *)arg1)->GetX();
18210
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 {
18215 resultobj = SWIG_From_int((int)(result));
18216 }
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj;
18225 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18226 int result;
18227 PyObject * obj0 = 0 ;
18228 char *kwnames[] = {
18229 (char *) "self", NULL
18230 };
18231
18232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18234 if (SWIG_arg_fail(1)) SWIG_fail;
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 result = (int)((wxKeyEvent const *)arg1)->GetY();
18238
18239 wxPyEndAllowThreads(__tstate);
18240 if (PyErr_Occurred()) SWIG_fail;
18241 }
18242 {
18243 resultobj = SWIG_From_int((int)(result));
18244 }
18245 return resultobj;
18246 fail:
18247 return NULL;
18248 }
18249
18250
18251 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18252 PyObject *resultobj;
18253 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18254 int arg2 ;
18255 PyObject * obj0 = 0 ;
18256 PyObject * obj1 = 0 ;
18257 char *kwnames[] = {
18258 (char *) "self",(char *) "m_x", NULL
18259 };
18260
18261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18263 if (SWIG_arg_fail(1)) SWIG_fail;
18264 {
18265 arg2 = (int)(SWIG_As_int(obj1));
18266 if (SWIG_arg_fail(2)) SWIG_fail;
18267 }
18268 if (arg1) (arg1)->m_x = arg2;
18269
18270 Py_INCREF(Py_None); resultobj = Py_None;
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj;
18279 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18280 int result;
18281 PyObject * obj0 = 0 ;
18282 char *kwnames[] = {
18283 (char *) "self", NULL
18284 };
18285
18286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18288 if (SWIG_arg_fail(1)) SWIG_fail;
18289 result = (int) ((arg1)->m_x);
18290
18291 {
18292 resultobj = SWIG_From_int((int)(result));
18293 }
18294 return resultobj;
18295 fail:
18296 return NULL;
18297 }
18298
18299
18300 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18301 PyObject *resultobj;
18302 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18303 int arg2 ;
18304 PyObject * obj0 = 0 ;
18305 PyObject * obj1 = 0 ;
18306 char *kwnames[] = {
18307 (char *) "self",(char *) "m_y", NULL
18308 };
18309
18310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18312 if (SWIG_arg_fail(1)) SWIG_fail;
18313 {
18314 arg2 = (int)(SWIG_As_int(obj1));
18315 if (SWIG_arg_fail(2)) SWIG_fail;
18316 }
18317 if (arg1) (arg1)->m_y = arg2;
18318
18319 Py_INCREF(Py_None); resultobj = Py_None;
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj;
18328 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18329 int result;
18330 PyObject * obj0 = 0 ;
18331 char *kwnames[] = {
18332 (char *) "self", NULL
18333 };
18334
18335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18337 if (SWIG_arg_fail(1)) SWIG_fail;
18338 result = (int) ((arg1)->m_y);
18339
18340 {
18341 resultobj = SWIG_From_int((int)(result));
18342 }
18343 return resultobj;
18344 fail:
18345 return NULL;
18346 }
18347
18348
18349 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18350 PyObject *resultobj;
18351 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18352 long arg2 ;
18353 PyObject * obj0 = 0 ;
18354 PyObject * obj1 = 0 ;
18355 char *kwnames[] = {
18356 (char *) "self",(char *) "m_keyCode", NULL
18357 };
18358
18359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18361 if (SWIG_arg_fail(1)) SWIG_fail;
18362 {
18363 arg2 = (long)(SWIG_As_long(obj1));
18364 if (SWIG_arg_fail(2)) SWIG_fail;
18365 }
18366 if (arg1) (arg1)->m_keyCode = arg2;
18367
18368 Py_INCREF(Py_None); resultobj = Py_None;
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj;
18377 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18378 long result;
18379 PyObject * obj0 = 0 ;
18380 char *kwnames[] = {
18381 (char *) "self", NULL
18382 };
18383
18384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18386 if (SWIG_arg_fail(1)) SWIG_fail;
18387 result = (long) ((arg1)->m_keyCode);
18388
18389 {
18390 resultobj = SWIG_From_long((long)(result));
18391 }
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18399 PyObject *resultobj;
18400 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18401 bool arg2 ;
18402 PyObject * obj0 = 0 ;
18403 PyObject * obj1 = 0 ;
18404 char *kwnames[] = {
18405 (char *) "self",(char *) "m_controlDown", NULL
18406 };
18407
18408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18410 if (SWIG_arg_fail(1)) SWIG_fail;
18411 {
18412 arg2 = (bool)(SWIG_As_bool(obj1));
18413 if (SWIG_arg_fail(2)) SWIG_fail;
18414 }
18415 if (arg1) (arg1)->m_controlDown = arg2;
18416
18417 Py_INCREF(Py_None); resultobj = Py_None;
18418 return resultobj;
18419 fail:
18420 return NULL;
18421 }
18422
18423
18424 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18425 PyObject *resultobj;
18426 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18427 bool result;
18428 PyObject * obj0 = 0 ;
18429 char *kwnames[] = {
18430 (char *) "self", NULL
18431 };
18432
18433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18435 if (SWIG_arg_fail(1)) SWIG_fail;
18436 result = (bool) ((arg1)->m_controlDown);
18437
18438 {
18439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18440 }
18441 return resultobj;
18442 fail:
18443 return NULL;
18444 }
18445
18446
18447 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18448 PyObject *resultobj;
18449 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18450 bool arg2 ;
18451 PyObject * obj0 = 0 ;
18452 PyObject * obj1 = 0 ;
18453 char *kwnames[] = {
18454 (char *) "self",(char *) "m_shiftDown", NULL
18455 };
18456
18457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) 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 arg2 = (bool)(SWIG_As_bool(obj1));
18462 if (SWIG_arg_fail(2)) SWIG_fail;
18463 }
18464 if (arg1) (arg1)->m_shiftDown = arg2;
18465
18466 Py_INCREF(Py_None); resultobj = Py_None;
18467 return resultobj;
18468 fail:
18469 return NULL;
18470 }
18471
18472
18473 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18474 PyObject *resultobj;
18475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18476 bool result;
18477 PyObject * obj0 = 0 ;
18478 char *kwnames[] = {
18479 (char *) "self", NULL
18480 };
18481
18482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18484 if (SWIG_arg_fail(1)) SWIG_fail;
18485 result = (bool) ((arg1)->m_shiftDown);
18486
18487 {
18488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18489 }
18490 return resultobj;
18491 fail:
18492 return NULL;
18493 }
18494
18495
18496 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18497 PyObject *resultobj;
18498 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18499 bool arg2 ;
18500 PyObject * obj0 = 0 ;
18501 PyObject * obj1 = 0 ;
18502 char *kwnames[] = {
18503 (char *) "self",(char *) "m_altDown", NULL
18504 };
18505
18506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18508 if (SWIG_arg_fail(1)) SWIG_fail;
18509 {
18510 arg2 = (bool)(SWIG_As_bool(obj1));
18511 if (SWIG_arg_fail(2)) SWIG_fail;
18512 }
18513 if (arg1) (arg1)->m_altDown = arg2;
18514
18515 Py_INCREF(Py_None); resultobj = Py_None;
18516 return resultobj;
18517 fail:
18518 return NULL;
18519 }
18520
18521
18522 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj;
18524 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18525 bool result;
18526 PyObject * obj0 = 0 ;
18527 char *kwnames[] = {
18528 (char *) "self", NULL
18529 };
18530
18531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18533 if (SWIG_arg_fail(1)) SWIG_fail;
18534 result = (bool) ((arg1)->m_altDown);
18535
18536 {
18537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18538 }
18539 return resultobj;
18540 fail:
18541 return NULL;
18542 }
18543
18544
18545 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18546 PyObject *resultobj;
18547 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18548 bool arg2 ;
18549 PyObject * obj0 = 0 ;
18550 PyObject * obj1 = 0 ;
18551 char *kwnames[] = {
18552 (char *) "self",(char *) "m_metaDown", NULL
18553 };
18554
18555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18557 if (SWIG_arg_fail(1)) SWIG_fail;
18558 {
18559 arg2 = (bool)(SWIG_As_bool(obj1));
18560 if (SWIG_arg_fail(2)) SWIG_fail;
18561 }
18562 if (arg1) (arg1)->m_metaDown = arg2;
18563
18564 Py_INCREF(Py_None); resultobj = Py_None;
18565 return resultobj;
18566 fail:
18567 return NULL;
18568 }
18569
18570
18571 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18572 PyObject *resultobj;
18573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18574 bool result;
18575 PyObject * obj0 = 0 ;
18576 char *kwnames[] = {
18577 (char *) "self", NULL
18578 };
18579
18580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18582 if (SWIG_arg_fail(1)) SWIG_fail;
18583 result = (bool) ((arg1)->m_metaDown);
18584
18585 {
18586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18587 }
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18595 PyObject *resultobj;
18596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18597 bool arg2 ;
18598 PyObject * obj0 = 0 ;
18599 PyObject * obj1 = 0 ;
18600 char *kwnames[] = {
18601 (char *) "self",(char *) "m_scanCode", NULL
18602 };
18603
18604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18606 if (SWIG_arg_fail(1)) SWIG_fail;
18607 {
18608 arg2 = (bool)(SWIG_As_bool(obj1));
18609 if (SWIG_arg_fail(2)) SWIG_fail;
18610 }
18611 if (arg1) (arg1)->m_scanCode = arg2;
18612
18613 Py_INCREF(Py_None); resultobj = Py_None;
18614 return resultobj;
18615 fail:
18616 return NULL;
18617 }
18618
18619
18620 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18621 PyObject *resultobj;
18622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18623 bool result;
18624 PyObject * obj0 = 0 ;
18625 char *kwnames[] = {
18626 (char *) "self", NULL
18627 };
18628
18629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18631 if (SWIG_arg_fail(1)) SWIG_fail;
18632 result = (bool) ((arg1)->m_scanCode);
18633
18634 {
18635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18636 }
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18644 PyObject *resultobj;
18645 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18646 unsigned int arg2 ;
18647 PyObject * obj0 = 0 ;
18648 PyObject * obj1 = 0 ;
18649 char *kwnames[] = {
18650 (char *) "self",(char *) "m_rawCode", NULL
18651 };
18652
18653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18655 if (SWIG_arg_fail(1)) SWIG_fail;
18656 {
18657 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18658 if (SWIG_arg_fail(2)) SWIG_fail;
18659 }
18660 if (arg1) (arg1)->m_rawCode = arg2;
18661
18662 Py_INCREF(Py_None); resultobj = Py_None;
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18670 PyObject *resultobj;
18671 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18672 unsigned int result;
18673 PyObject * obj0 = 0 ;
18674 char *kwnames[] = {
18675 (char *) "self", NULL
18676 };
18677
18678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18680 if (SWIG_arg_fail(1)) SWIG_fail;
18681 result = (unsigned int) ((arg1)->m_rawCode);
18682
18683 {
18684 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18685 }
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj;
18694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18695 unsigned int arg2 ;
18696 PyObject * obj0 = 0 ;
18697 PyObject * obj1 = 0 ;
18698 char *kwnames[] = {
18699 (char *) "self",(char *) "m_rawFlags", NULL
18700 };
18701
18702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18704 if (SWIG_arg_fail(1)) SWIG_fail;
18705 {
18706 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18707 if (SWIG_arg_fail(2)) SWIG_fail;
18708 }
18709 if (arg1) (arg1)->m_rawFlags = arg2;
18710
18711 Py_INCREF(Py_None); resultobj = Py_None;
18712 return resultobj;
18713 fail:
18714 return NULL;
18715 }
18716
18717
18718 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18719 PyObject *resultobj;
18720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18721 unsigned int result;
18722 PyObject * obj0 = 0 ;
18723 char *kwnames[] = {
18724 (char *) "self", NULL
18725 };
18726
18727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18729 if (SWIG_arg_fail(1)) SWIG_fail;
18730 result = (unsigned int) ((arg1)->m_rawFlags);
18731
18732 {
18733 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18734 }
18735 return resultobj;
18736 fail:
18737 return NULL;
18738 }
18739
18740
18741 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18742 PyObject *obj;
18743 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18744 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18745 Py_INCREF(obj);
18746 return Py_BuildValue((char *)"");
18747 }
18748 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj;
18750 wxSize const &arg1_defvalue = wxDefaultSize ;
18751 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18752 int arg2 = (int) 0 ;
18753 wxSizeEvent *result;
18754 wxSize temp1 ;
18755 PyObject * obj0 = 0 ;
18756 PyObject * obj1 = 0 ;
18757 char *kwnames[] = {
18758 (char *) "sz",(char *) "winid", NULL
18759 };
18760
18761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18762 if (obj0) {
18763 {
18764 arg1 = &temp1;
18765 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18766 }
18767 }
18768 if (obj1) {
18769 {
18770 arg2 = (int)(SWIG_As_int(obj1));
18771 if (SWIG_arg_fail(2)) SWIG_fail;
18772 }
18773 }
18774 {
18775 PyThreadState* __tstate = wxPyBeginAllowThreads();
18776 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18777
18778 wxPyEndAllowThreads(__tstate);
18779 if (PyErr_Occurred()) SWIG_fail;
18780 }
18781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18782 return resultobj;
18783 fail:
18784 return NULL;
18785 }
18786
18787
18788 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18789 PyObject *resultobj;
18790 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18791 wxSize result;
18792 PyObject * obj0 = 0 ;
18793 char *kwnames[] = {
18794 (char *) "self", NULL
18795 };
18796
18797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18799 if (SWIG_arg_fail(1)) SWIG_fail;
18800 {
18801 PyThreadState* __tstate = wxPyBeginAllowThreads();
18802 result = ((wxSizeEvent const *)arg1)->GetSize();
18803
18804 wxPyEndAllowThreads(__tstate);
18805 if (PyErr_Occurred()) SWIG_fail;
18806 }
18807 {
18808 wxSize * resultptr;
18809 resultptr = new wxSize((wxSize &)(result));
18810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18811 }
18812 return resultobj;
18813 fail:
18814 return NULL;
18815 }
18816
18817
18818 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18819 PyObject *resultobj;
18820 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18821 wxRect result;
18822 PyObject * obj0 = 0 ;
18823 char *kwnames[] = {
18824 (char *) "self", NULL
18825 };
18826
18827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18829 if (SWIG_arg_fail(1)) SWIG_fail;
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = ((wxSizeEvent const *)arg1)->GetRect();
18833
18834 wxPyEndAllowThreads(__tstate);
18835 if (PyErr_Occurred()) SWIG_fail;
18836 }
18837 {
18838 wxRect * resultptr;
18839 resultptr = new wxRect((wxRect &)(result));
18840 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18841 }
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18849 PyObject *resultobj;
18850 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18851 wxRect arg2 ;
18852 PyObject * obj0 = 0 ;
18853 PyObject * obj1 = 0 ;
18854 char *kwnames[] = {
18855 (char *) "self",(char *) "rect", NULL
18856 };
18857
18858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18860 if (SWIG_arg_fail(1)) SWIG_fail;
18861 {
18862 wxRect * argp;
18863 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18864 if (SWIG_arg_fail(2)) SWIG_fail;
18865 if (argp == NULL) {
18866 SWIG_null_ref("wxRect");
18867 }
18868 if (SWIG_arg_fail(2)) SWIG_fail;
18869 arg2 = *argp;
18870 }
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 (arg1)->SetRect(arg2);
18874
18875 wxPyEndAllowThreads(__tstate);
18876 if (PyErr_Occurred()) SWIG_fail;
18877 }
18878 Py_INCREF(Py_None); resultobj = Py_None;
18879 return resultobj;
18880 fail:
18881 return NULL;
18882 }
18883
18884
18885 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18886 PyObject *resultobj;
18887 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18888 wxSize arg2 ;
18889 PyObject * obj0 = 0 ;
18890 PyObject * obj1 = 0 ;
18891 char *kwnames[] = {
18892 (char *) "self",(char *) "size", NULL
18893 };
18894
18895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18897 if (SWIG_arg_fail(1)) SWIG_fail;
18898 {
18899 wxSize * argp;
18900 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18901 if (SWIG_arg_fail(2)) SWIG_fail;
18902 if (argp == NULL) {
18903 SWIG_null_ref("wxSize");
18904 }
18905 if (SWIG_arg_fail(2)) SWIG_fail;
18906 arg2 = *argp;
18907 }
18908 {
18909 PyThreadState* __tstate = wxPyBeginAllowThreads();
18910 wxSizeEvent_SetSize(arg1,arg2);
18911
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 Py_INCREF(Py_None); resultobj = Py_None;
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18923 PyObject *resultobj;
18924 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18925 wxSize *arg2 = (wxSize *) 0 ;
18926 PyObject * obj0 = 0 ;
18927 PyObject * obj1 = 0 ;
18928 char *kwnames[] = {
18929 (char *) "self",(char *) "m_size", NULL
18930 };
18931
18932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18934 if (SWIG_arg_fail(1)) SWIG_fail;
18935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18936 if (SWIG_arg_fail(2)) SWIG_fail;
18937 if (arg1) (arg1)->m_size = *arg2;
18938
18939 Py_INCREF(Py_None); resultobj = Py_None;
18940 return resultobj;
18941 fail:
18942 return NULL;
18943 }
18944
18945
18946 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18947 PyObject *resultobj;
18948 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18949 wxSize *result;
18950 PyObject * obj0 = 0 ;
18951 char *kwnames[] = {
18952 (char *) "self", NULL
18953 };
18954
18955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18957 if (SWIG_arg_fail(1)) SWIG_fail;
18958 result = (wxSize *)& ((arg1)->m_size);
18959
18960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj;
18969 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18970 wxRect *arg2 = (wxRect *) 0 ;
18971 PyObject * obj0 = 0 ;
18972 PyObject * obj1 = 0 ;
18973 char *kwnames[] = {
18974 (char *) "self",(char *) "m_rect", NULL
18975 };
18976
18977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18979 if (SWIG_arg_fail(1)) SWIG_fail;
18980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(2)) SWIG_fail;
18982 if (arg1) (arg1)->m_rect = *arg2;
18983
18984 Py_INCREF(Py_None); resultobj = Py_None;
18985 return resultobj;
18986 fail:
18987 return NULL;
18988 }
18989
18990
18991 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18992 PyObject *resultobj;
18993 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18994 wxRect *result;
18995 PyObject * obj0 = 0 ;
18996 char *kwnames[] = {
18997 (char *) "self", NULL
18998 };
18999
19000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19002 if (SWIG_arg_fail(1)) SWIG_fail;
19003 result = (wxRect *)& ((arg1)->m_rect);
19004
19005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19013 PyObject *obj;
19014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19015 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19016 Py_INCREF(obj);
19017 return Py_BuildValue((char *)"");
19018 }
19019 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj;
19021 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19022 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19023 int arg2 = (int) 0 ;
19024 wxMoveEvent *result;
19025 wxPoint temp1 ;
19026 PyObject * obj0 = 0 ;
19027 PyObject * obj1 = 0 ;
19028 char *kwnames[] = {
19029 (char *) "pos",(char *) "winid", NULL
19030 };
19031
19032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19033 if (obj0) {
19034 {
19035 arg1 = &temp1;
19036 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19037 }
19038 }
19039 if (obj1) {
19040 {
19041 arg2 = (int)(SWIG_As_int(obj1));
19042 if (SWIG_arg_fail(2)) SWIG_fail;
19043 }
19044 }
19045 {
19046 PyThreadState* __tstate = wxPyBeginAllowThreads();
19047 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19048
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj;
19061 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19062 wxPoint result;
19063 PyObject * obj0 = 0 ;
19064 char *kwnames[] = {
19065 (char *) "self", NULL
19066 };
19067
19068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19070 if (SWIG_arg_fail(1)) SWIG_fail;
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 result = ((wxMoveEvent const *)arg1)->GetPosition();
19074
19075 wxPyEndAllowThreads(__tstate);
19076 if (PyErr_Occurred()) SWIG_fail;
19077 }
19078 {
19079 wxPoint * resultptr;
19080 resultptr = new wxPoint((wxPoint &)(result));
19081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19082 }
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19090 PyObject *resultobj;
19091 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19092 wxRect result;
19093 PyObject * obj0 = 0 ;
19094 char *kwnames[] = {
19095 (char *) "self", NULL
19096 };
19097
19098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19100 if (SWIG_arg_fail(1)) SWIG_fail;
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = ((wxMoveEvent const *)arg1)->GetRect();
19104
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 {
19109 wxRect * resultptr;
19110 resultptr = new wxRect((wxRect &)(result));
19111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19112 }
19113 return resultobj;
19114 fail:
19115 return NULL;
19116 }
19117
19118
19119 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19120 PyObject *resultobj;
19121 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19122 wxRect *arg2 = 0 ;
19123 wxRect temp2 ;
19124 PyObject * obj0 = 0 ;
19125 PyObject * obj1 = 0 ;
19126 char *kwnames[] = {
19127 (char *) "self",(char *) "rect", NULL
19128 };
19129
19130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19132 if (SWIG_arg_fail(1)) SWIG_fail;
19133 {
19134 arg2 = &temp2;
19135 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19136 }
19137 {
19138 PyThreadState* __tstate = wxPyBeginAllowThreads();
19139 (arg1)->SetRect((wxRect const &)*arg2);
19140
19141 wxPyEndAllowThreads(__tstate);
19142 if (PyErr_Occurred()) SWIG_fail;
19143 }
19144 Py_INCREF(Py_None); resultobj = Py_None;
19145 return resultobj;
19146 fail:
19147 return NULL;
19148 }
19149
19150
19151 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19152 PyObject *resultobj;
19153 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19154 wxPoint *arg2 = 0 ;
19155 wxPoint temp2 ;
19156 PyObject * obj0 = 0 ;
19157 PyObject * obj1 = 0 ;
19158 char *kwnames[] = {
19159 (char *) "self",(char *) "pos", NULL
19160 };
19161
19162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19164 if (SWIG_arg_fail(1)) SWIG_fail;
19165 {
19166 arg2 = &temp2;
19167 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19168 }
19169 {
19170 PyThreadState* __tstate = wxPyBeginAllowThreads();
19171 (arg1)->SetPosition((wxPoint const &)*arg2);
19172
19173 wxPyEndAllowThreads(__tstate);
19174 if (PyErr_Occurred()) SWIG_fail;
19175 }
19176 Py_INCREF(Py_None); resultobj = Py_None;
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19184 PyObject *obj;
19185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19186 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19187 Py_INCREF(obj);
19188 return Py_BuildValue((char *)"");
19189 }
19190 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj;
19192 int arg1 = (int) 0 ;
19193 wxPaintEvent *result;
19194 PyObject * obj0 = 0 ;
19195 char *kwnames[] = {
19196 (char *) "Id", NULL
19197 };
19198
19199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19200 if (obj0) {
19201 {
19202 arg1 = (int)(SWIG_As_int(obj0));
19203 if (SWIG_arg_fail(1)) SWIG_fail;
19204 }
19205 }
19206 {
19207 PyThreadState* __tstate = wxPyBeginAllowThreads();
19208 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19209
19210 wxPyEndAllowThreads(__tstate);
19211 if (PyErr_Occurred()) SWIG_fail;
19212 }
19213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19214 return resultobj;
19215 fail:
19216 return NULL;
19217 }
19218
19219
19220 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19221 PyObject *obj;
19222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19223 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19224 Py_INCREF(obj);
19225 return Py_BuildValue((char *)"");
19226 }
19227 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19228 PyObject *resultobj;
19229 int arg1 = (int) 0 ;
19230 wxNcPaintEvent *result;
19231 PyObject * obj0 = 0 ;
19232 char *kwnames[] = {
19233 (char *) "winid", NULL
19234 };
19235
19236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19237 if (obj0) {
19238 {
19239 arg1 = (int)(SWIG_As_int(obj0));
19240 if (SWIG_arg_fail(1)) SWIG_fail;
19241 }
19242 }
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19246
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19258 PyObject *obj;
19259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19260 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19261 Py_INCREF(obj);
19262 return Py_BuildValue((char *)"");
19263 }
19264 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj;
19266 int arg1 = (int) 0 ;
19267 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19268 wxEraseEvent *result;
19269 PyObject * obj0 = 0 ;
19270 PyObject * obj1 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "Id",(char *) "dc", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19276 if (obj0) {
19277 {
19278 arg1 = (int)(SWIG_As_int(obj0));
19279 if (SWIG_arg_fail(1)) SWIG_fail;
19280 }
19281 }
19282 if (obj1) {
19283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19284 if (SWIG_arg_fail(2)) SWIG_fail;
19285 }
19286 {
19287 PyThreadState* __tstate = wxPyBeginAllowThreads();
19288 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19289
19290 wxPyEndAllowThreads(__tstate);
19291 if (PyErr_Occurred()) SWIG_fail;
19292 }
19293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19294 return resultobj;
19295 fail:
19296 return NULL;
19297 }
19298
19299
19300 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19301 PyObject *resultobj;
19302 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19303 wxDC *result;
19304 PyObject * obj0 = 0 ;
19305 char *kwnames[] = {
19306 (char *) "self", NULL
19307 };
19308
19309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19311 if (SWIG_arg_fail(1)) SWIG_fail;
19312 {
19313 PyThreadState* __tstate = wxPyBeginAllowThreads();
19314 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19315
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 {
19320 resultobj = wxPyMake_wxObject(result, 0);
19321 }
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19329 PyObject *obj;
19330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19331 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19332 Py_INCREF(obj);
19333 return Py_BuildValue((char *)"");
19334 }
19335 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19336 PyObject *resultobj;
19337 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19338 int arg2 = (int) 0 ;
19339 wxFocusEvent *result;
19340 PyObject * obj0 = 0 ;
19341 PyObject * obj1 = 0 ;
19342 char *kwnames[] = {
19343 (char *) "type",(char *) "winid", NULL
19344 };
19345
19346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19347 if (obj0) {
19348 {
19349 arg1 = (wxEventType)(SWIG_As_int(obj0));
19350 if (SWIG_arg_fail(1)) SWIG_fail;
19351 }
19352 }
19353 if (obj1) {
19354 {
19355 arg2 = (int)(SWIG_As_int(obj1));
19356 if (SWIG_arg_fail(2)) SWIG_fail;
19357 }
19358 }
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19362
19363 wxPyEndAllowThreads(__tstate);
19364 if (PyErr_Occurred()) SWIG_fail;
19365 }
19366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19367 return resultobj;
19368 fail:
19369 return NULL;
19370 }
19371
19372
19373 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19374 PyObject *resultobj;
19375 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19376 wxWindow *result;
19377 PyObject * obj0 = 0 ;
19378 char *kwnames[] = {
19379 (char *) "self", NULL
19380 };
19381
19382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19384 if (SWIG_arg_fail(1)) SWIG_fail;
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19388
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 {
19393 resultobj = wxPyMake_wxObject(result, 0);
19394 }
19395 return resultobj;
19396 fail:
19397 return NULL;
19398 }
19399
19400
19401 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19402 PyObject *resultobj;
19403 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19404 wxWindow *arg2 = (wxWindow *) 0 ;
19405 PyObject * obj0 = 0 ;
19406 PyObject * obj1 = 0 ;
19407 char *kwnames[] = {
19408 (char *) "self",(char *) "win", NULL
19409 };
19410
19411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19413 if (SWIG_arg_fail(1)) SWIG_fail;
19414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19415 if (SWIG_arg_fail(2)) SWIG_fail;
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 (arg1)->SetWindow(arg2);
19419
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 Py_INCREF(Py_None); resultobj = Py_None;
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19431 PyObject *obj;
19432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19433 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19434 Py_INCREF(obj);
19435 return Py_BuildValue((char *)"");
19436 }
19437 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19438 PyObject *resultobj;
19439 wxWindow *arg1 = (wxWindow *) NULL ;
19440 wxChildFocusEvent *result;
19441 PyObject * obj0 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "win", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19447 if (obj0) {
19448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19449 if (SWIG_arg_fail(1)) SWIG_fail;
19450 }
19451 {
19452 PyThreadState* __tstate = wxPyBeginAllowThreads();
19453 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19454
19455 wxPyEndAllowThreads(__tstate);
19456 if (PyErr_Occurred()) SWIG_fail;
19457 }
19458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19459 return resultobj;
19460 fail:
19461 return NULL;
19462 }
19463
19464
19465 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19466 PyObject *resultobj;
19467 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19468 wxWindow *result;
19469 PyObject * obj0 = 0 ;
19470 char *kwnames[] = {
19471 (char *) "self", NULL
19472 };
19473
19474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19476 if (SWIG_arg_fail(1)) SWIG_fail;
19477 {
19478 PyThreadState* __tstate = wxPyBeginAllowThreads();
19479 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19480
19481 wxPyEndAllowThreads(__tstate);
19482 if (PyErr_Occurred()) SWIG_fail;
19483 }
19484 {
19485 resultobj = wxPyMake_wxObject(result, 0);
19486 }
19487 return resultobj;
19488 fail:
19489 return NULL;
19490 }
19491
19492
19493 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19494 PyObject *obj;
19495 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19496 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19497 Py_INCREF(obj);
19498 return Py_BuildValue((char *)"");
19499 }
19500 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19501 PyObject *resultobj;
19502 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19503 bool arg2 = (bool) true ;
19504 int arg3 = (int) 0 ;
19505 wxActivateEvent *result;
19506 PyObject * obj0 = 0 ;
19507 PyObject * obj1 = 0 ;
19508 PyObject * obj2 = 0 ;
19509 char *kwnames[] = {
19510 (char *) "type",(char *) "active",(char *) "Id", NULL
19511 };
19512
19513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19514 if (obj0) {
19515 {
19516 arg1 = (wxEventType)(SWIG_As_int(obj0));
19517 if (SWIG_arg_fail(1)) SWIG_fail;
19518 }
19519 }
19520 if (obj1) {
19521 {
19522 arg2 = (bool)(SWIG_As_bool(obj1));
19523 if (SWIG_arg_fail(2)) SWIG_fail;
19524 }
19525 }
19526 if (obj2) {
19527 {
19528 arg3 = (int)(SWIG_As_int(obj2));
19529 if (SWIG_arg_fail(3)) SWIG_fail;
19530 }
19531 }
19532 {
19533 PyThreadState* __tstate = wxPyBeginAllowThreads();
19534 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19535
19536 wxPyEndAllowThreads(__tstate);
19537 if (PyErr_Occurred()) SWIG_fail;
19538 }
19539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19540 return resultobj;
19541 fail:
19542 return NULL;
19543 }
19544
19545
19546 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19547 PyObject *resultobj;
19548 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19549 bool result;
19550 PyObject * obj0 = 0 ;
19551 char *kwnames[] = {
19552 (char *) "self", NULL
19553 };
19554
19555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19557 if (SWIG_arg_fail(1)) SWIG_fail;
19558 {
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19561
19562 wxPyEndAllowThreads(__tstate);
19563 if (PyErr_Occurred()) SWIG_fail;
19564 }
19565 {
19566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19567 }
19568 return resultobj;
19569 fail:
19570 return NULL;
19571 }
19572
19573
19574 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19575 PyObject *obj;
19576 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19577 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19578 Py_INCREF(obj);
19579 return Py_BuildValue((char *)"");
19580 }
19581 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj;
19583 int arg1 = (int) 0 ;
19584 wxInitDialogEvent *result;
19585 PyObject * obj0 = 0 ;
19586 char *kwnames[] = {
19587 (char *) "Id", NULL
19588 };
19589
19590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19591 if (obj0) {
19592 {
19593 arg1 = (int)(SWIG_As_int(obj0));
19594 if (SWIG_arg_fail(1)) SWIG_fail;
19595 }
19596 }
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19600
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19612 PyObject *obj;
19613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19614 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19615 Py_INCREF(obj);
19616 return Py_BuildValue((char *)"");
19617 }
19618 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19619 PyObject *resultobj;
19620 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19621 int arg2 = (int) 0 ;
19622 wxMenu *arg3 = (wxMenu *) NULL ;
19623 wxMenuEvent *result;
19624 PyObject * obj0 = 0 ;
19625 PyObject * obj1 = 0 ;
19626 PyObject * obj2 = 0 ;
19627 char *kwnames[] = {
19628 (char *) "type",(char *) "winid",(char *) "menu", NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19632 if (obj0) {
19633 {
19634 arg1 = (wxEventType)(SWIG_As_int(obj0));
19635 if (SWIG_arg_fail(1)) SWIG_fail;
19636 }
19637 }
19638 if (obj1) {
19639 {
19640 arg2 = (int)(SWIG_As_int(obj1));
19641 if (SWIG_arg_fail(2)) SWIG_fail;
19642 }
19643 }
19644 if (obj2) {
19645 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19646 if (SWIG_arg_fail(3)) SWIG_fail;
19647 }
19648 {
19649 PyThreadState* __tstate = wxPyBeginAllowThreads();
19650 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19651
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj;
19664 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19665 int result;
19666 PyObject * obj0 = 0 ;
19667 char *kwnames[] = {
19668 (char *) "self", NULL
19669 };
19670
19671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19673 if (SWIG_arg_fail(1)) SWIG_fail;
19674 {
19675 PyThreadState* __tstate = wxPyBeginAllowThreads();
19676 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19677
19678 wxPyEndAllowThreads(__tstate);
19679 if (PyErr_Occurred()) SWIG_fail;
19680 }
19681 {
19682 resultobj = SWIG_From_int((int)(result));
19683 }
19684 return resultobj;
19685 fail:
19686 return NULL;
19687 }
19688
19689
19690 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19691 PyObject *resultobj;
19692 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19693 bool result;
19694 PyObject * obj0 = 0 ;
19695 char *kwnames[] = {
19696 (char *) "self", NULL
19697 };
19698
19699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19701 if (SWIG_arg_fail(1)) SWIG_fail;
19702 {
19703 PyThreadState* __tstate = wxPyBeginAllowThreads();
19704 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19705
19706 wxPyEndAllowThreads(__tstate);
19707 if (PyErr_Occurred()) SWIG_fail;
19708 }
19709 {
19710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19711 }
19712 return resultobj;
19713 fail:
19714 return NULL;
19715 }
19716
19717
19718 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19719 PyObject *resultobj;
19720 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19721 wxMenu *result;
19722 PyObject * obj0 = 0 ;
19723 char *kwnames[] = {
19724 (char *) "self", NULL
19725 };
19726
19727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19729 if (SWIG_arg_fail(1)) SWIG_fail;
19730 {
19731 PyThreadState* __tstate = wxPyBeginAllowThreads();
19732 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19733
19734 wxPyEndAllowThreads(__tstate);
19735 if (PyErr_Occurred()) SWIG_fail;
19736 }
19737 {
19738 resultobj = wxPyMake_wxObject(result, 0);
19739 }
19740 return resultobj;
19741 fail:
19742 return NULL;
19743 }
19744
19745
19746 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19747 PyObject *obj;
19748 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19749 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19750 Py_INCREF(obj);
19751 return Py_BuildValue((char *)"");
19752 }
19753 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj;
19755 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19756 int arg2 = (int) 0 ;
19757 wxCloseEvent *result;
19758 PyObject * obj0 = 0 ;
19759 PyObject * obj1 = 0 ;
19760 char *kwnames[] = {
19761 (char *) "type",(char *) "winid", NULL
19762 };
19763
19764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19765 if (obj0) {
19766 {
19767 arg1 = (wxEventType)(SWIG_As_int(obj0));
19768 if (SWIG_arg_fail(1)) SWIG_fail;
19769 }
19770 }
19771 if (obj1) {
19772 {
19773 arg2 = (int)(SWIG_As_int(obj1));
19774 if (SWIG_arg_fail(2)) SWIG_fail;
19775 }
19776 }
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19780
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19785 return resultobj;
19786 fail:
19787 return NULL;
19788 }
19789
19790
19791 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19792 PyObject *resultobj;
19793 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19794 bool arg2 ;
19795 PyObject * obj0 = 0 ;
19796 PyObject * obj1 = 0 ;
19797 char *kwnames[] = {
19798 (char *) "self",(char *) "logOff", NULL
19799 };
19800
19801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19803 if (SWIG_arg_fail(1)) SWIG_fail;
19804 {
19805 arg2 = (bool)(SWIG_As_bool(obj1));
19806 if (SWIG_arg_fail(2)) SWIG_fail;
19807 }
19808 {
19809 PyThreadState* __tstate = wxPyBeginAllowThreads();
19810 (arg1)->SetLoggingOff(arg2);
19811
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 Py_INCREF(Py_None); resultobj = Py_None;
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj;
19824 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19825 bool result;
19826 PyObject * obj0 = 0 ;
19827 char *kwnames[] = {
19828 (char *) "self", NULL
19829 };
19830
19831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19833 if (SWIG_arg_fail(1)) SWIG_fail;
19834 {
19835 PyThreadState* __tstate = wxPyBeginAllowThreads();
19836 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19837
19838 wxPyEndAllowThreads(__tstate);
19839 if (PyErr_Occurred()) SWIG_fail;
19840 }
19841 {
19842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19843 }
19844 return resultobj;
19845 fail:
19846 return NULL;
19847 }
19848
19849
19850 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19851 PyObject *resultobj;
19852 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19853 bool arg2 = (bool) true ;
19854 PyObject * obj0 = 0 ;
19855 PyObject * obj1 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "self",(char *) "veto", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19862 if (SWIG_arg_fail(1)) SWIG_fail;
19863 if (obj1) {
19864 {
19865 arg2 = (bool)(SWIG_As_bool(obj1));
19866 if (SWIG_arg_fail(2)) SWIG_fail;
19867 }
19868 }
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 (arg1)->Veto(arg2);
19872
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 Py_INCREF(Py_None); resultobj = Py_None;
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj;
19885 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19886 bool arg2 ;
19887 PyObject * obj0 = 0 ;
19888 PyObject * obj1 = 0 ;
19889 char *kwnames[] = {
19890 (char *) "self",(char *) "canVeto", NULL
19891 };
19892
19893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19895 if (SWIG_arg_fail(1)) SWIG_fail;
19896 {
19897 arg2 = (bool)(SWIG_As_bool(obj1));
19898 if (SWIG_arg_fail(2)) SWIG_fail;
19899 }
19900 {
19901 PyThreadState* __tstate = wxPyBeginAllowThreads();
19902 (arg1)->SetCanVeto(arg2);
19903
19904 wxPyEndAllowThreads(__tstate);
19905 if (PyErr_Occurred()) SWIG_fail;
19906 }
19907 Py_INCREF(Py_None); resultobj = Py_None;
19908 return resultobj;
19909 fail:
19910 return NULL;
19911 }
19912
19913
19914 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19915 PyObject *resultobj;
19916 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19917 bool result;
19918 PyObject * obj0 = 0 ;
19919 char *kwnames[] = {
19920 (char *) "self", NULL
19921 };
19922
19923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19925 if (SWIG_arg_fail(1)) SWIG_fail;
19926 {
19927 PyThreadState* __tstate = wxPyBeginAllowThreads();
19928 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19929
19930 wxPyEndAllowThreads(__tstate);
19931 if (PyErr_Occurred()) SWIG_fail;
19932 }
19933 {
19934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19935 }
19936 return resultobj;
19937 fail:
19938 return NULL;
19939 }
19940
19941
19942 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19943 PyObject *resultobj;
19944 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19945 bool result;
19946 PyObject * obj0 = 0 ;
19947 char *kwnames[] = {
19948 (char *) "self", NULL
19949 };
19950
19951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19953 if (SWIG_arg_fail(1)) SWIG_fail;
19954 {
19955 PyThreadState* __tstate = wxPyBeginAllowThreads();
19956 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19957
19958 wxPyEndAllowThreads(__tstate);
19959 if (PyErr_Occurred()) SWIG_fail;
19960 }
19961 {
19962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19963 }
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19971 PyObject *obj;
19972 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19973 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19974 Py_INCREF(obj);
19975 return Py_BuildValue((char *)"");
19976 }
19977 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19978 PyObject *resultobj;
19979 int arg1 = (int) 0 ;
19980 bool arg2 = (bool) false ;
19981 wxShowEvent *result;
19982 PyObject * obj0 = 0 ;
19983 PyObject * obj1 = 0 ;
19984 char *kwnames[] = {
19985 (char *) "winid",(char *) "show", NULL
19986 };
19987
19988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19989 if (obj0) {
19990 {
19991 arg1 = (int)(SWIG_As_int(obj0));
19992 if (SWIG_arg_fail(1)) SWIG_fail;
19993 }
19994 }
19995 if (obj1) {
19996 {
19997 arg2 = (bool)(SWIG_As_bool(obj1));
19998 if (SWIG_arg_fail(2)) SWIG_fail;
19999 }
20000 }
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20004
20005 wxPyEndAllowThreads(__tstate);
20006 if (PyErr_Occurred()) SWIG_fail;
20007 }
20008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20009 return resultobj;
20010 fail:
20011 return NULL;
20012 }
20013
20014
20015 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20016 PyObject *resultobj;
20017 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20018 bool arg2 ;
20019 PyObject * obj0 = 0 ;
20020 PyObject * obj1 = 0 ;
20021 char *kwnames[] = {
20022 (char *) "self",(char *) "show", NULL
20023 };
20024
20025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20027 if (SWIG_arg_fail(1)) SWIG_fail;
20028 {
20029 arg2 = (bool)(SWIG_As_bool(obj1));
20030 if (SWIG_arg_fail(2)) SWIG_fail;
20031 }
20032 {
20033 PyThreadState* __tstate = wxPyBeginAllowThreads();
20034 (arg1)->SetShow(arg2);
20035
20036 wxPyEndAllowThreads(__tstate);
20037 if (PyErr_Occurred()) SWIG_fail;
20038 }
20039 Py_INCREF(Py_None); resultobj = Py_None;
20040 return resultobj;
20041 fail:
20042 return NULL;
20043 }
20044
20045
20046 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20047 PyObject *resultobj;
20048 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20049 bool result;
20050 PyObject * obj0 = 0 ;
20051 char *kwnames[] = {
20052 (char *) "self", NULL
20053 };
20054
20055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20057 if (SWIG_arg_fail(1)) SWIG_fail;
20058 {
20059 PyThreadState* __tstate = wxPyBeginAllowThreads();
20060 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20061
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 {
20066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20067 }
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20075 PyObject *obj;
20076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20077 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20078 Py_INCREF(obj);
20079 return Py_BuildValue((char *)"");
20080 }
20081 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20082 PyObject *resultobj;
20083 int arg1 = (int) 0 ;
20084 bool arg2 = (bool) true ;
20085 wxIconizeEvent *result;
20086 PyObject * obj0 = 0 ;
20087 PyObject * obj1 = 0 ;
20088 char *kwnames[] = {
20089 (char *) "id",(char *) "iconized", NULL
20090 };
20091
20092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20093 if (obj0) {
20094 {
20095 arg1 = (int)(SWIG_As_int(obj0));
20096 if (SWIG_arg_fail(1)) SWIG_fail;
20097 }
20098 }
20099 if (obj1) {
20100 {
20101 arg2 = (bool)(SWIG_As_bool(obj1));
20102 if (SWIG_arg_fail(2)) SWIG_fail;
20103 }
20104 }
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20108
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20120 PyObject *resultobj;
20121 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20122 bool result;
20123 PyObject * obj0 = 0 ;
20124 char *kwnames[] = {
20125 (char *) "self", NULL
20126 };
20127
20128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20130 if (SWIG_arg_fail(1)) SWIG_fail;
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (bool)(arg1)->Iconized();
20134
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 {
20139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20140 }
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20148 PyObject *obj;
20149 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20150 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20151 Py_INCREF(obj);
20152 return Py_BuildValue((char *)"");
20153 }
20154 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20155 PyObject *resultobj;
20156 int arg1 = (int) 0 ;
20157 wxMaximizeEvent *result;
20158 PyObject * obj0 = 0 ;
20159 char *kwnames[] = {
20160 (char *) "id", NULL
20161 };
20162
20163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20164 if (obj0) {
20165 {
20166 arg1 = (int)(SWIG_As_int(obj0));
20167 if (SWIG_arg_fail(1)) SWIG_fail;
20168 }
20169 }
20170 {
20171 PyThreadState* __tstate = wxPyBeginAllowThreads();
20172 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20173
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20185 PyObject *obj;
20186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20187 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20188 Py_INCREF(obj);
20189 return Py_BuildValue((char *)"");
20190 }
20191 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20194 wxPoint result;
20195 PyObject * obj0 = 0 ;
20196 char *kwnames[] = {
20197 (char *) "self", NULL
20198 };
20199
20200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20202 if (SWIG_arg_fail(1)) SWIG_fail;
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (arg1)->GetPosition();
20206
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 {
20211 wxPoint * resultptr;
20212 resultptr = new wxPoint((wxPoint &)(result));
20213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20214 }
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj;
20223 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20224 int result;
20225 PyObject * obj0 = 0 ;
20226 char *kwnames[] = {
20227 (char *) "self", NULL
20228 };
20229
20230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20232 if (SWIG_arg_fail(1)) SWIG_fail;
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (int)(arg1)->GetNumberOfFiles();
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 {
20241 resultobj = SWIG_From_int((int)(result));
20242 }
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20250 PyObject *resultobj;
20251 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20252 PyObject *result;
20253 PyObject * obj0 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 resultobj = result;
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20276 PyObject *obj;
20277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20278 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20279 Py_INCREF(obj);
20280 return Py_BuildValue((char *)"");
20281 }
20282 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj;
20284 int arg1 = (int) 0 ;
20285 wxUpdateUIEvent *result;
20286 PyObject * obj0 = 0 ;
20287 char *kwnames[] = {
20288 (char *) "commandId", NULL
20289 };
20290
20291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20292 if (obj0) {
20293 {
20294 arg1 = (int)(SWIG_As_int(obj0));
20295 if (SWIG_arg_fail(1)) SWIG_fail;
20296 }
20297 }
20298 {
20299 PyThreadState* __tstate = wxPyBeginAllowThreads();
20300 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20301
20302 wxPyEndAllowThreads(__tstate);
20303 if (PyErr_Occurred()) SWIG_fail;
20304 }
20305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20313 PyObject *resultobj;
20314 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20315 bool result;
20316 PyObject * obj0 = 0 ;
20317 char *kwnames[] = {
20318 (char *) "self", NULL
20319 };
20320
20321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20323 if (SWIG_arg_fail(1)) SWIG_fail;
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 {
20332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20333 }
20334 return resultobj;
20335 fail:
20336 return NULL;
20337 }
20338
20339
20340 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20341 PyObject *resultobj;
20342 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20343 bool result;
20344 PyObject * obj0 = 0 ;
20345 char *kwnames[] = {
20346 (char *) "self", NULL
20347 };
20348
20349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20351 if (SWIG_arg_fail(1)) SWIG_fail;
20352 {
20353 PyThreadState* __tstate = wxPyBeginAllowThreads();
20354 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20355
20356 wxPyEndAllowThreads(__tstate);
20357 if (PyErr_Occurred()) SWIG_fail;
20358 }
20359 {
20360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20361 }
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj;
20370 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20371 wxString result;
20372 PyObject * obj0 = 0 ;
20373 char *kwnames[] = {
20374 (char *) "self", NULL
20375 };
20376
20377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20379 if (SWIG_arg_fail(1)) SWIG_fail;
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20383
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 {
20388 #if wxUSE_UNICODE
20389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20390 #else
20391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20392 #endif
20393 }
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj;
20402 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20403 bool result;
20404 PyObject * obj0 = 0 ;
20405 char *kwnames[] = {
20406 (char *) "self", NULL
20407 };
20408
20409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20411 if (SWIG_arg_fail(1)) SWIG_fail;
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20415
20416 wxPyEndAllowThreads(__tstate);
20417 if (PyErr_Occurred()) SWIG_fail;
20418 }
20419 {
20420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20421 }
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj;
20430 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20431 bool result;
20432 PyObject * obj0 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "self", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20439 if (SWIG_arg_fail(1)) SWIG_fail;
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20443
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20449 }
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20457 PyObject *resultobj;
20458 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20459 bool result;
20460 PyObject * obj0 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20471
20472 wxPyEndAllowThreads(__tstate);
20473 if (PyErr_Occurred()) SWIG_fail;
20474 }
20475 {
20476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20477 }
20478 return resultobj;
20479 fail:
20480 return NULL;
20481 }
20482
20483
20484 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20485 PyObject *resultobj;
20486 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20487 bool arg2 ;
20488 PyObject * obj0 = 0 ;
20489 PyObject * obj1 = 0 ;
20490 char *kwnames[] = {
20491 (char *) "self",(char *) "check", NULL
20492 };
20493
20494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20496 if (SWIG_arg_fail(1)) SWIG_fail;
20497 {
20498 arg2 = (bool)(SWIG_As_bool(obj1));
20499 if (SWIG_arg_fail(2)) SWIG_fail;
20500 }
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 (arg1)->Check(arg2);
20504
20505 wxPyEndAllowThreads(__tstate);
20506 if (PyErr_Occurred()) SWIG_fail;
20507 }
20508 Py_INCREF(Py_None); resultobj = Py_None;
20509 return resultobj;
20510 fail:
20511 return NULL;
20512 }
20513
20514
20515 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20516 PyObject *resultobj;
20517 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20518 bool arg2 ;
20519 PyObject * obj0 = 0 ;
20520 PyObject * obj1 = 0 ;
20521 char *kwnames[] = {
20522 (char *) "self",(char *) "enable", NULL
20523 };
20524
20525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20527 if (SWIG_arg_fail(1)) SWIG_fail;
20528 {
20529 arg2 = (bool)(SWIG_As_bool(obj1));
20530 if (SWIG_arg_fail(2)) SWIG_fail;
20531 }
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 (arg1)->Enable(arg2);
20535
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 Py_INCREF(Py_None); resultobj = Py_None;
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20547 PyObject *resultobj;
20548 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20549 wxString *arg2 = 0 ;
20550 bool temp2 = false ;
20551 PyObject * obj0 = 0 ;
20552 PyObject * obj1 = 0 ;
20553 char *kwnames[] = {
20554 (char *) "self",(char *) "text", NULL
20555 };
20556
20557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20559 if (SWIG_arg_fail(1)) SWIG_fail;
20560 {
20561 arg2 = wxString_in_helper(obj1);
20562 if (arg2 == NULL) SWIG_fail;
20563 temp2 = true;
20564 }
20565 {
20566 PyThreadState* __tstate = wxPyBeginAllowThreads();
20567 (arg1)->SetText((wxString const &)*arg2);
20568
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 Py_INCREF(Py_None); resultobj = Py_None;
20573 {
20574 if (temp2)
20575 delete arg2;
20576 }
20577 return resultobj;
20578 fail:
20579 {
20580 if (temp2)
20581 delete arg2;
20582 }
20583 return NULL;
20584 }
20585
20586
20587 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20588 PyObject *resultobj;
20589 long arg1 ;
20590 PyObject * obj0 = 0 ;
20591 char *kwnames[] = {
20592 (char *) "updateInterval", NULL
20593 };
20594
20595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20596 {
20597 arg1 = (long)(SWIG_As_long(obj0));
20598 if (SWIG_arg_fail(1)) SWIG_fail;
20599 }
20600 {
20601 PyThreadState* __tstate = wxPyBeginAllowThreads();
20602 wxUpdateUIEvent::SetUpdateInterval(arg1);
20603
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 Py_INCREF(Py_None); resultobj = Py_None;
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20615 PyObject *resultobj;
20616 long result;
20617 char *kwnames[] = {
20618 NULL
20619 };
20620
20621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20625
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 {
20630 resultobj = SWIG_From_long((long)(result));
20631 }
20632 return resultobj;
20633 fail:
20634 return NULL;
20635 }
20636
20637
20638 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20639 PyObject *resultobj;
20640 wxWindow *arg1 = (wxWindow *) 0 ;
20641 bool result;
20642 PyObject * obj0 = 0 ;
20643 char *kwnames[] = {
20644 (char *) "win", NULL
20645 };
20646
20647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20649 if (SWIG_arg_fail(1)) SWIG_fail;
20650 {
20651 PyThreadState* __tstate = wxPyBeginAllowThreads();
20652 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20653
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 {
20658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20659 }
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20667 PyObject *resultobj;
20668 char *kwnames[] = {
20669 NULL
20670 };
20671
20672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 wxUpdateUIEvent::ResetUpdateTime();
20676
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 Py_INCREF(Py_None); resultobj = Py_None;
20681 return resultobj;
20682 fail:
20683 return NULL;
20684 }
20685
20686
20687 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20688 PyObject *resultobj;
20689 wxUpdateUIMode arg1 ;
20690 PyObject * obj0 = 0 ;
20691 char *kwnames[] = {
20692 (char *) "mode", NULL
20693 };
20694
20695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20696 {
20697 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20698 if (SWIG_arg_fail(1)) SWIG_fail;
20699 }
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 Py_INCREF(Py_None); resultobj = Py_None;
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20715 PyObject *resultobj;
20716 wxUpdateUIMode result;
20717 char *kwnames[] = {
20718 NULL
20719 };
20720
20721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20722 {
20723 PyThreadState* __tstate = wxPyBeginAllowThreads();
20724 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20725
20726 wxPyEndAllowThreads(__tstate);
20727 if (PyErr_Occurred()) SWIG_fail;
20728 }
20729 resultobj = SWIG_From_int((result));
20730 return resultobj;
20731 fail:
20732 return NULL;
20733 }
20734
20735
20736 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20737 PyObject *obj;
20738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20739 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20740 Py_INCREF(obj);
20741 return Py_BuildValue((char *)"");
20742 }
20743 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20744 PyObject *resultobj;
20745 wxSysColourChangedEvent *result;
20746 char *kwnames[] = {
20747 NULL
20748 };
20749
20750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20751 {
20752 PyThreadState* __tstate = wxPyBeginAllowThreads();
20753 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20754
20755 wxPyEndAllowThreads(__tstate);
20756 if (PyErr_Occurred()) SWIG_fail;
20757 }
20758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20759 return resultobj;
20760 fail:
20761 return NULL;
20762 }
20763
20764
20765 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20766 PyObject *obj;
20767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20768 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20769 Py_INCREF(obj);
20770 return Py_BuildValue((char *)"");
20771 }
20772 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20773 PyObject *resultobj;
20774 int arg1 = (int) 0 ;
20775 wxWindow *arg2 = (wxWindow *) NULL ;
20776 wxMouseCaptureChangedEvent *result;
20777 PyObject * obj0 = 0 ;
20778 PyObject * obj1 = 0 ;
20779 char *kwnames[] = {
20780 (char *) "winid",(char *) "gainedCapture", NULL
20781 };
20782
20783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20784 if (obj0) {
20785 {
20786 arg1 = (int)(SWIG_As_int(obj0));
20787 if (SWIG_arg_fail(1)) SWIG_fail;
20788 }
20789 }
20790 if (obj1) {
20791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20792 if (SWIG_arg_fail(2)) SWIG_fail;
20793 }
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20797
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20809 PyObject *resultobj;
20810 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20811 wxWindow *result;
20812 PyObject * obj0 = 0 ;
20813 char *kwnames[] = {
20814 (char *) "self", NULL
20815 };
20816
20817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20819 if (SWIG_arg_fail(1)) SWIG_fail;
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20823
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 resultobj = wxPyMake_wxObject(result, 0);
20829 }
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20837 PyObject *obj;
20838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20839 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20840 Py_INCREF(obj);
20841 return Py_BuildValue((char *)"");
20842 }
20843 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20844 PyObject *resultobj;
20845 wxDisplayChangedEvent *result;
20846 char *kwnames[] = {
20847 NULL
20848 };
20849
20850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20854
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20866 PyObject *obj;
20867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20868 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20869 Py_INCREF(obj);
20870 return Py_BuildValue((char *)"");
20871 }
20872 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20873 PyObject *resultobj;
20874 int arg1 = (int) 0 ;
20875 wxPaletteChangedEvent *result;
20876 PyObject * obj0 = 0 ;
20877 char *kwnames[] = {
20878 (char *) "id", NULL
20879 };
20880
20881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20882 if (obj0) {
20883 {
20884 arg1 = (int)(SWIG_As_int(obj0));
20885 if (SWIG_arg_fail(1)) SWIG_fail;
20886 }
20887 }
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20891
20892 wxPyEndAllowThreads(__tstate);
20893 if (PyErr_Occurred()) SWIG_fail;
20894 }
20895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20896 return resultobj;
20897 fail:
20898 return NULL;
20899 }
20900
20901
20902 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20903 PyObject *resultobj;
20904 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20905 wxWindow *arg2 = (wxWindow *) 0 ;
20906 PyObject * obj0 = 0 ;
20907 PyObject * obj1 = 0 ;
20908 char *kwnames[] = {
20909 (char *) "self",(char *) "win", NULL
20910 };
20911
20912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20914 if (SWIG_arg_fail(1)) SWIG_fail;
20915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20916 if (SWIG_arg_fail(2)) SWIG_fail;
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 (arg1)->SetChangedWindow(arg2);
20920
20921 wxPyEndAllowThreads(__tstate);
20922 if (PyErr_Occurred()) SWIG_fail;
20923 }
20924 Py_INCREF(Py_None); resultobj = Py_None;
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20932 PyObject *resultobj;
20933 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20934 wxWindow *result;
20935 PyObject * obj0 = 0 ;
20936 char *kwnames[] = {
20937 (char *) "self", NULL
20938 };
20939
20940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20942 if (SWIG_arg_fail(1)) SWIG_fail;
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 result = (wxWindow *)(arg1)->GetChangedWindow();
20946
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 {
20951 resultobj = wxPyMake_wxObject(result, 0);
20952 }
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20960 PyObject *obj;
20961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20962 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20963 Py_INCREF(obj);
20964 return Py_BuildValue((char *)"");
20965 }
20966 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj;
20968 int arg1 = (int) 0 ;
20969 wxQueryNewPaletteEvent *result;
20970 PyObject * obj0 = 0 ;
20971 char *kwnames[] = {
20972 (char *) "winid", NULL
20973 };
20974
20975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20976 if (obj0) {
20977 {
20978 arg1 = (int)(SWIG_As_int(obj0));
20979 if (SWIG_arg_fail(1)) SWIG_fail;
20980 }
20981 }
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20997 PyObject *resultobj;
20998 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20999 bool arg2 ;
21000 PyObject * obj0 = 0 ;
21001 PyObject * obj1 = 0 ;
21002 char *kwnames[] = {
21003 (char *) "self",(char *) "realized", NULL
21004 };
21005
21006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21008 if (SWIG_arg_fail(1)) SWIG_fail;
21009 {
21010 arg2 = (bool)(SWIG_As_bool(obj1));
21011 if (SWIG_arg_fail(2)) SWIG_fail;
21012 }
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 (arg1)->SetPaletteRealized(arg2);
21016
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 Py_INCREF(Py_None); resultobj = Py_None;
21021 return resultobj;
21022 fail:
21023 return NULL;
21024 }
21025
21026
21027 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21028 PyObject *resultobj;
21029 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21030 bool result;
21031 PyObject * obj0 = 0 ;
21032 char *kwnames[] = {
21033 (char *) "self", NULL
21034 };
21035
21036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21038 if (SWIG_arg_fail(1)) SWIG_fail;
21039 {
21040 PyThreadState* __tstate = wxPyBeginAllowThreads();
21041 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21042
21043 wxPyEndAllowThreads(__tstate);
21044 if (PyErr_Occurred()) SWIG_fail;
21045 }
21046 {
21047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21048 }
21049 return resultobj;
21050 fail:
21051 return NULL;
21052 }
21053
21054
21055 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21056 PyObject *obj;
21057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21058 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21059 Py_INCREF(obj);
21060 return Py_BuildValue((char *)"");
21061 }
21062 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21063 PyObject *resultobj;
21064 wxNavigationKeyEvent *result;
21065 char *kwnames[] = {
21066 NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21070 {
21071 PyThreadState* __tstate = wxPyBeginAllowThreads();
21072 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21073
21074 wxPyEndAllowThreads(__tstate);
21075 if (PyErr_Occurred()) SWIG_fail;
21076 }
21077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21078 return resultobj;
21079 fail:
21080 return NULL;
21081 }
21082
21083
21084 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21085 PyObject *resultobj;
21086 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21087 bool result;
21088 PyObject * obj0 = 0 ;
21089 char *kwnames[] = {
21090 (char *) "self", NULL
21091 };
21092
21093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21095 if (SWIG_arg_fail(1)) SWIG_fail;
21096 {
21097 PyThreadState* __tstate = wxPyBeginAllowThreads();
21098 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21099
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 {
21104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21105 }
21106 return resultobj;
21107 fail:
21108 return NULL;
21109 }
21110
21111
21112 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21113 PyObject *resultobj;
21114 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21115 bool arg2 ;
21116 PyObject * obj0 = 0 ;
21117 PyObject * obj1 = 0 ;
21118 char *kwnames[] = {
21119 (char *) "self",(char *) "forward", NULL
21120 };
21121
21122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21124 if (SWIG_arg_fail(1)) SWIG_fail;
21125 {
21126 arg2 = (bool)(SWIG_As_bool(obj1));
21127 if (SWIG_arg_fail(2)) SWIG_fail;
21128 }
21129 {
21130 PyThreadState* __tstate = wxPyBeginAllowThreads();
21131 (arg1)->SetDirection(arg2);
21132
21133 wxPyEndAllowThreads(__tstate);
21134 if (PyErr_Occurred()) SWIG_fail;
21135 }
21136 Py_INCREF(Py_None); resultobj = Py_None;
21137 return resultobj;
21138 fail:
21139 return NULL;
21140 }
21141
21142
21143 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21144 PyObject *resultobj;
21145 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21146 bool result;
21147 PyObject * obj0 = 0 ;
21148 char *kwnames[] = {
21149 (char *) "self", NULL
21150 };
21151
21152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21154 if (SWIG_arg_fail(1)) SWIG_fail;
21155 {
21156 PyThreadState* __tstate = wxPyBeginAllowThreads();
21157 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21158
21159 wxPyEndAllowThreads(__tstate);
21160 if (PyErr_Occurred()) SWIG_fail;
21161 }
21162 {
21163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21164 }
21165 return resultobj;
21166 fail:
21167 return NULL;
21168 }
21169
21170
21171 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21172 PyObject *resultobj;
21173 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21174 bool arg2 ;
21175 PyObject * obj0 = 0 ;
21176 PyObject * obj1 = 0 ;
21177 char *kwnames[] = {
21178 (char *) "self",(char *) "ischange", NULL
21179 };
21180
21181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21183 if (SWIG_arg_fail(1)) SWIG_fail;
21184 {
21185 arg2 = (bool)(SWIG_As_bool(obj1));
21186 if (SWIG_arg_fail(2)) SWIG_fail;
21187 }
21188 {
21189 PyThreadState* __tstate = wxPyBeginAllowThreads();
21190 (arg1)->SetWindowChange(arg2);
21191
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 Py_INCREF(Py_None); resultobj = Py_None;
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21203 PyObject *resultobj;
21204 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21205 bool result;
21206 PyObject * obj0 = 0 ;
21207 char *kwnames[] = {
21208 (char *) "self", NULL
21209 };
21210
21211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21213 if (SWIG_arg_fail(1)) SWIG_fail;
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21217
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 {
21222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21223 }
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj;
21232 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21233 bool arg2 ;
21234 PyObject * obj0 = 0 ;
21235 PyObject * obj1 = 0 ;
21236 char *kwnames[] = {
21237 (char *) "self",(char *) "bIs", NULL
21238 };
21239
21240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21242 if (SWIG_arg_fail(1)) SWIG_fail;
21243 {
21244 arg2 = (bool)(SWIG_As_bool(obj1));
21245 if (SWIG_arg_fail(2)) SWIG_fail;
21246 }
21247 {
21248 PyThreadState* __tstate = wxPyBeginAllowThreads();
21249 (arg1)->SetFromTab(arg2);
21250
21251 wxPyEndAllowThreads(__tstate);
21252 if (PyErr_Occurred()) SWIG_fail;
21253 }
21254 Py_INCREF(Py_None); resultobj = Py_None;
21255 return resultobj;
21256 fail:
21257 return NULL;
21258 }
21259
21260
21261 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21262 PyObject *resultobj;
21263 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21264 long arg2 ;
21265 PyObject * obj0 = 0 ;
21266 PyObject * obj1 = 0 ;
21267 char *kwnames[] = {
21268 (char *) "self",(char *) "flags", NULL
21269 };
21270
21271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21273 if (SWIG_arg_fail(1)) SWIG_fail;
21274 {
21275 arg2 = (long)(SWIG_As_long(obj1));
21276 if (SWIG_arg_fail(2)) SWIG_fail;
21277 }
21278 {
21279 PyThreadState* __tstate = wxPyBeginAllowThreads();
21280 (arg1)->SetFlags(arg2);
21281
21282 wxPyEndAllowThreads(__tstate);
21283 if (PyErr_Occurred()) SWIG_fail;
21284 }
21285 Py_INCREF(Py_None); resultobj = Py_None;
21286 return resultobj;
21287 fail:
21288 return NULL;
21289 }
21290
21291
21292 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21293 PyObject *resultobj;
21294 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21295 wxWindow *result;
21296 PyObject * obj0 = 0 ;
21297 char *kwnames[] = {
21298 (char *) "self", NULL
21299 };
21300
21301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21303 if (SWIG_arg_fail(1)) SWIG_fail;
21304 {
21305 PyThreadState* __tstate = wxPyBeginAllowThreads();
21306 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21307
21308 wxPyEndAllowThreads(__tstate);
21309 if (PyErr_Occurred()) SWIG_fail;
21310 }
21311 {
21312 resultobj = wxPyMake_wxObject(result, 0);
21313 }
21314 return resultobj;
21315 fail:
21316 return NULL;
21317 }
21318
21319
21320 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21321 PyObject *resultobj;
21322 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21323 wxWindow *arg2 = (wxWindow *) 0 ;
21324 PyObject * obj0 = 0 ;
21325 PyObject * obj1 = 0 ;
21326 char *kwnames[] = {
21327 (char *) "self",(char *) "win", NULL
21328 };
21329
21330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21332 if (SWIG_arg_fail(1)) SWIG_fail;
21333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21334 if (SWIG_arg_fail(2)) SWIG_fail;
21335 {
21336 PyThreadState* __tstate = wxPyBeginAllowThreads();
21337 (arg1)->SetCurrentFocus(arg2);
21338
21339 wxPyEndAllowThreads(__tstate);
21340 if (PyErr_Occurred()) SWIG_fail;
21341 }
21342 Py_INCREF(Py_None); resultobj = Py_None;
21343 return resultobj;
21344 fail:
21345 return NULL;
21346 }
21347
21348
21349 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21350 PyObject *obj;
21351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21352 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21353 Py_INCREF(obj);
21354 return Py_BuildValue((char *)"");
21355 }
21356 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21357 PyObject *resultobj;
21358 wxWindow *arg1 = (wxWindow *) NULL ;
21359 wxWindowCreateEvent *result;
21360 PyObject * obj0 = 0 ;
21361 char *kwnames[] = {
21362 (char *) "win", NULL
21363 };
21364
21365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21366 if (obj0) {
21367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21368 if (SWIG_arg_fail(1)) SWIG_fail;
21369 }
21370 {
21371 PyThreadState* __tstate = wxPyBeginAllowThreads();
21372 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21373
21374 wxPyEndAllowThreads(__tstate);
21375 if (PyErr_Occurred()) SWIG_fail;
21376 }
21377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21378 return resultobj;
21379 fail:
21380 return NULL;
21381 }
21382
21383
21384 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21385 PyObject *resultobj;
21386 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21387 wxWindow *result;
21388 PyObject * obj0 = 0 ;
21389 char *kwnames[] = {
21390 (char *) "self", NULL
21391 };
21392
21393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21395 if (SWIG_arg_fail(1)) SWIG_fail;
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21399
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 {
21404 resultobj = wxPyMake_wxObject(result, 0);
21405 }
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21413 PyObject *obj;
21414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21415 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21416 Py_INCREF(obj);
21417 return Py_BuildValue((char *)"");
21418 }
21419 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21420 PyObject *resultobj;
21421 wxWindow *arg1 = (wxWindow *) NULL ;
21422 wxWindowDestroyEvent *result;
21423 PyObject * obj0 = 0 ;
21424 char *kwnames[] = {
21425 (char *) "win", NULL
21426 };
21427
21428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21429 if (obj0) {
21430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21431 if (SWIG_arg_fail(1)) SWIG_fail;
21432 }
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21436
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21450 wxWindow *result;
21451 PyObject * obj0 = 0 ;
21452 char *kwnames[] = {
21453 (char *) "self", NULL
21454 };
21455
21456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(1)) SWIG_fail;
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21462
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 resultobj = wxPyMake_wxObject(result, 0);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21476 PyObject *obj;
21477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21478 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21479 Py_INCREF(obj);
21480 return Py_BuildValue((char *)"");
21481 }
21482 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21485 int arg2 = (int) 0 ;
21486 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21487 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21488 wxContextMenuEvent *result;
21489 wxPoint temp3 ;
21490 PyObject * obj0 = 0 ;
21491 PyObject * obj1 = 0 ;
21492 PyObject * obj2 = 0 ;
21493 char *kwnames[] = {
21494 (char *) "type",(char *) "winid",(char *) "pt", NULL
21495 };
21496
21497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21498 if (obj0) {
21499 {
21500 arg1 = (wxEventType)(SWIG_As_int(obj0));
21501 if (SWIG_arg_fail(1)) SWIG_fail;
21502 }
21503 }
21504 if (obj1) {
21505 {
21506 arg2 = (int)(SWIG_As_int(obj1));
21507 if (SWIG_arg_fail(2)) SWIG_fail;
21508 }
21509 }
21510 if (obj2) {
21511 {
21512 arg3 = &temp3;
21513 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21514 }
21515 }
21516 {
21517 PyThreadState* __tstate = wxPyBeginAllowThreads();
21518 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21519
21520 wxPyEndAllowThreads(__tstate);
21521 if (PyErr_Occurred()) SWIG_fail;
21522 }
21523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21524 return resultobj;
21525 fail:
21526 return NULL;
21527 }
21528
21529
21530 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj;
21532 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21533 wxPoint *result;
21534 PyObject * obj0 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "self", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21541 if (SWIG_arg_fail(1)) SWIG_fail;
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 {
21545 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21546 result = (wxPoint *) &_result_ref;
21547 }
21548
21549 wxPyEndAllowThreads(__tstate);
21550 if (PyErr_Occurred()) SWIG_fail;
21551 }
21552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21553 return resultobj;
21554 fail:
21555 return NULL;
21556 }
21557
21558
21559 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21560 PyObject *resultobj;
21561 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21562 wxPoint *arg2 = 0 ;
21563 wxPoint temp2 ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 char *kwnames[] = {
21567 (char *) "self",(char *) "pos", NULL
21568 };
21569
21570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21572 if (SWIG_arg_fail(1)) SWIG_fail;
21573 {
21574 arg2 = &temp2;
21575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21576 }
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 (arg1)->SetPosition((wxPoint const &)*arg2);
21580
21581 wxPyEndAllowThreads(__tstate);
21582 if (PyErr_Occurred()) SWIG_fail;
21583 }
21584 Py_INCREF(Py_None); resultobj = Py_None;
21585 return resultobj;
21586 fail:
21587 return NULL;
21588 }
21589
21590
21591 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21592 PyObject *obj;
21593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21594 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21595 Py_INCREF(obj);
21596 return Py_BuildValue((char *)"");
21597 }
21598 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21599 PyObject *resultobj;
21600 wxIdleEvent *result;
21601 char *kwnames[] = {
21602 NULL
21603 };
21604
21605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21606 {
21607 PyThreadState* __tstate = wxPyBeginAllowThreads();
21608 result = (wxIdleEvent *)new wxIdleEvent();
21609
21610 wxPyEndAllowThreads(__tstate);
21611 if (PyErr_Occurred()) SWIG_fail;
21612 }
21613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21614 return resultobj;
21615 fail:
21616 return NULL;
21617 }
21618
21619
21620 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj;
21622 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21623 bool arg2 = (bool) true ;
21624 PyObject * obj0 = 0 ;
21625 PyObject * obj1 = 0 ;
21626 char *kwnames[] = {
21627 (char *) "self",(char *) "needMore", NULL
21628 };
21629
21630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21632 if (SWIG_arg_fail(1)) SWIG_fail;
21633 if (obj1) {
21634 {
21635 arg2 = (bool)(SWIG_As_bool(obj1));
21636 if (SWIG_arg_fail(2)) SWIG_fail;
21637 }
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 (arg1)->RequestMore(arg2);
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 Py_INCREF(Py_None); resultobj = Py_None;
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21654 PyObject *resultobj;
21655 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21656 bool result;
21657 PyObject * obj0 = 0 ;
21658 char *kwnames[] = {
21659 (char *) "self", NULL
21660 };
21661
21662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21664 if (SWIG_arg_fail(1)) SWIG_fail;
21665 {
21666 PyThreadState* __tstate = wxPyBeginAllowThreads();
21667 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21668
21669 wxPyEndAllowThreads(__tstate);
21670 if (PyErr_Occurred()) SWIG_fail;
21671 }
21672 {
21673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21674 }
21675 return resultobj;
21676 fail:
21677 return NULL;
21678 }
21679
21680
21681 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21682 PyObject *resultobj;
21683 wxIdleMode arg1 ;
21684 PyObject * obj0 = 0 ;
21685 char *kwnames[] = {
21686 (char *) "mode", NULL
21687 };
21688
21689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21690 {
21691 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21692 if (SWIG_arg_fail(1)) SWIG_fail;
21693 }
21694 {
21695 PyThreadState* __tstate = wxPyBeginAllowThreads();
21696 wxIdleEvent::SetMode((wxIdleMode )arg1);
21697
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 Py_INCREF(Py_None); resultobj = Py_None;
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj;
21710 wxIdleMode result;
21711 char *kwnames[] = {
21712 NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (wxIdleMode)wxIdleEvent::GetMode();
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 resultobj = SWIG_From_int((result));
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21731 PyObject *resultobj;
21732 wxWindow *arg1 = (wxWindow *) 0 ;
21733 bool result;
21734 PyObject * obj0 = 0 ;
21735 char *kwnames[] = {
21736 (char *) "win", NULL
21737 };
21738
21739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21741 if (SWIG_arg_fail(1)) SWIG_fail;
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 result = (bool)wxIdleEvent::CanSend(arg1);
21745
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
21749 {
21750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21751 }
21752 return resultobj;
21753 fail:
21754 return NULL;
21755 }
21756
21757
21758 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21759 PyObject *obj;
21760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21761 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21762 Py_INCREF(obj);
21763 return Py_BuildValue((char *)"");
21764 }
21765 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21766 PyObject *resultobj;
21767 int arg1 = (int) 0 ;
21768 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21769 wxPyEvent *result;
21770 PyObject * obj0 = 0 ;
21771 PyObject * obj1 = 0 ;
21772 char *kwnames[] = {
21773 (char *) "winid",(char *) "commandType", NULL
21774 };
21775
21776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21777 if (obj0) {
21778 {
21779 arg1 = (int)(SWIG_As_int(obj0));
21780 if (SWIG_arg_fail(1)) SWIG_fail;
21781 }
21782 }
21783 if (obj1) {
21784 {
21785 arg2 = (wxEventType)(SWIG_As_int(obj1));
21786 if (SWIG_arg_fail(2)) SWIG_fail;
21787 }
21788 }
21789 {
21790 PyThreadState* __tstate = wxPyBeginAllowThreads();
21791 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21792
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21797 return resultobj;
21798 fail:
21799 return NULL;
21800 }
21801
21802
21803 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21804 PyObject *resultobj;
21805 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21806 PyObject * obj0 = 0 ;
21807 char *kwnames[] = {
21808 (char *) "self", NULL
21809 };
21810
21811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21813 if (SWIG_arg_fail(1)) SWIG_fail;
21814 {
21815 PyThreadState* __tstate = wxPyBeginAllowThreads();
21816 delete arg1;
21817
21818 wxPyEndAllowThreads(__tstate);
21819 if (PyErr_Occurred()) SWIG_fail;
21820 }
21821 Py_INCREF(Py_None); resultobj = Py_None;
21822 return resultobj;
21823 fail:
21824 return NULL;
21825 }
21826
21827
21828 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21829 PyObject *resultobj;
21830 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21831 PyObject *arg2 = (PyObject *) 0 ;
21832 PyObject * obj0 = 0 ;
21833 PyObject * obj1 = 0 ;
21834 char *kwnames[] = {
21835 (char *) "self",(char *) "self", NULL
21836 };
21837
21838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21840 if (SWIG_arg_fail(1)) SWIG_fail;
21841 arg2 = obj1;
21842 {
21843 PyThreadState* __tstate = wxPyBeginAllowThreads();
21844 (arg1)->SetSelf(arg2);
21845
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 Py_INCREF(Py_None); resultobj = Py_None;
21850 return resultobj;
21851 fail:
21852 return NULL;
21853 }
21854
21855
21856 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21857 PyObject *resultobj;
21858 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21859 PyObject *result;
21860 PyObject * obj0 = 0 ;
21861 char *kwnames[] = {
21862 (char *) "self", NULL
21863 };
21864
21865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21867 if (SWIG_arg_fail(1)) SWIG_fail;
21868 {
21869 PyThreadState* __tstate = wxPyBeginAllowThreads();
21870 result = (PyObject *)(arg1)->GetSelf();
21871
21872 wxPyEndAllowThreads(__tstate);
21873 if (PyErr_Occurred()) SWIG_fail;
21874 }
21875 resultobj = result;
21876 return resultobj;
21877 fail:
21878 return NULL;
21879 }
21880
21881
21882 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21883 PyObject *obj;
21884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21885 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21886 Py_INCREF(obj);
21887 return Py_BuildValue((char *)"");
21888 }
21889 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21890 PyObject *resultobj;
21891 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21892 int arg2 = (int) 0 ;
21893 wxPyCommandEvent *result;
21894 PyObject * obj0 = 0 ;
21895 PyObject * obj1 = 0 ;
21896 char *kwnames[] = {
21897 (char *) "commandType",(char *) "id", NULL
21898 };
21899
21900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21901 if (obj0) {
21902 {
21903 arg1 = (wxEventType)(SWIG_As_int(obj0));
21904 if (SWIG_arg_fail(1)) SWIG_fail;
21905 }
21906 }
21907 if (obj1) {
21908 {
21909 arg2 = (int)(SWIG_As_int(obj1));
21910 if (SWIG_arg_fail(2)) SWIG_fail;
21911 }
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21916
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21928 PyObject *resultobj;
21929 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21930 PyObject * obj0 = 0 ;
21931 char *kwnames[] = {
21932 (char *) "self", NULL
21933 };
21934
21935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21937 if (SWIG_arg_fail(1)) SWIG_fail;
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 delete arg1;
21941
21942 wxPyEndAllowThreads(__tstate);
21943 if (PyErr_Occurred()) SWIG_fail;
21944 }
21945 Py_INCREF(Py_None); resultobj = Py_None;
21946 return resultobj;
21947 fail:
21948 return NULL;
21949 }
21950
21951
21952 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21953 PyObject *resultobj;
21954 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21955 PyObject *arg2 = (PyObject *) 0 ;
21956 PyObject * obj0 = 0 ;
21957 PyObject * obj1 = 0 ;
21958 char *kwnames[] = {
21959 (char *) "self",(char *) "self", NULL
21960 };
21961
21962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21964 if (SWIG_arg_fail(1)) SWIG_fail;
21965 arg2 = obj1;
21966 {
21967 PyThreadState* __tstate = wxPyBeginAllowThreads();
21968 (arg1)->SetSelf(arg2);
21969
21970 wxPyEndAllowThreads(__tstate);
21971 if (PyErr_Occurred()) SWIG_fail;
21972 }
21973 Py_INCREF(Py_None); resultobj = Py_None;
21974 return resultobj;
21975 fail:
21976 return NULL;
21977 }
21978
21979
21980 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21981 PyObject *resultobj;
21982 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21983 PyObject *result;
21984 PyObject * obj0 = 0 ;
21985 char *kwnames[] = {
21986 (char *) "self", NULL
21987 };
21988
21989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21991 if (SWIG_arg_fail(1)) SWIG_fail;
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 result = (PyObject *)(arg1)->GetSelf();
21995
21996 wxPyEndAllowThreads(__tstate);
21997 if (PyErr_Occurred()) SWIG_fail;
21998 }
21999 resultobj = result;
22000 return resultobj;
22001 fail:
22002 return NULL;
22003 }
22004
22005
22006 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22007 PyObject *obj;
22008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22009 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22010 Py_INCREF(obj);
22011 return Py_BuildValue((char *)"");
22012 }
22013 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22014 PyObject *resultobj;
22015 wxWindow *arg1 = (wxWindow *) 0 ;
22016 wxDateTime *arg2 = 0 ;
22017 wxEventType arg3 ;
22018 wxDateEvent *result;
22019 PyObject * obj0 = 0 ;
22020 PyObject * obj1 = 0 ;
22021 PyObject * obj2 = 0 ;
22022 char *kwnames[] = {
22023 (char *) "win",(char *) "dt",(char *) "type", NULL
22024 };
22025
22026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22028 if (SWIG_arg_fail(1)) SWIG_fail;
22029 {
22030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22031 if (SWIG_arg_fail(2)) SWIG_fail;
22032 if (arg2 == NULL) {
22033 SWIG_null_ref("wxDateTime");
22034 }
22035 if (SWIG_arg_fail(2)) SWIG_fail;
22036 }
22037 {
22038 arg3 = (wxEventType)(SWIG_As_int(obj2));
22039 if (SWIG_arg_fail(3)) SWIG_fail;
22040 }
22041 {
22042 PyThreadState* __tstate = wxPyBeginAllowThreads();
22043 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22044
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22056 PyObject *resultobj;
22057 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22058 wxDateTime *result;
22059 PyObject * obj0 = 0 ;
22060 char *kwnames[] = {
22061 (char *) "self", NULL
22062 };
22063
22064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22066 if (SWIG_arg_fail(1)) SWIG_fail;
22067 {
22068 PyThreadState* __tstate = wxPyBeginAllowThreads();
22069 {
22070 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22071 result = (wxDateTime *) &_result_ref;
22072 }
22073
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22085 PyObject *resultobj;
22086 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22087 wxDateTime *arg2 = 0 ;
22088 PyObject * obj0 = 0 ;
22089 PyObject * obj1 = 0 ;
22090 char *kwnames[] = {
22091 (char *) "self",(char *) "date", NULL
22092 };
22093
22094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22096 if (SWIG_arg_fail(1)) SWIG_fail;
22097 {
22098 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22099 if (SWIG_arg_fail(2)) SWIG_fail;
22100 if (arg2 == NULL) {
22101 SWIG_null_ref("wxDateTime");
22102 }
22103 if (SWIG_arg_fail(2)) SWIG_fail;
22104 }
22105 {
22106 PyThreadState* __tstate = wxPyBeginAllowThreads();
22107 (arg1)->SetDate((wxDateTime const &)*arg2);
22108
22109 wxPyEndAllowThreads(__tstate);
22110 if (PyErr_Occurred()) SWIG_fail;
22111 }
22112 Py_INCREF(Py_None); resultobj = Py_None;
22113 return resultobj;
22114 fail:
22115 return NULL;
22116 }
22117
22118
22119 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22120 PyObject *obj;
22121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22122 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22123 Py_INCREF(obj);
22124 return Py_BuildValue((char *)"");
22125 }
22126 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22127 PyObject *resultobj;
22128 wxPyApp *result;
22129 char *kwnames[] = {
22130 NULL
22131 };
22132
22133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22134 {
22135 PyThreadState* __tstate = wxPyBeginAllowThreads();
22136 result = (wxPyApp *)new_wxPyApp();
22137
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22149 PyObject *resultobj;
22150 wxPyApp *arg1 = (wxPyApp *) 0 ;
22151 PyObject * obj0 = 0 ;
22152 char *kwnames[] = {
22153 (char *) "self", NULL
22154 };
22155
22156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22158 if (SWIG_arg_fail(1)) SWIG_fail;
22159 {
22160 PyThreadState* __tstate = wxPyBeginAllowThreads();
22161 delete arg1;
22162
22163 wxPyEndAllowThreads(__tstate);
22164 if (PyErr_Occurred()) SWIG_fail;
22165 }
22166 Py_INCREF(Py_None); resultobj = Py_None;
22167 return resultobj;
22168 fail:
22169 return NULL;
22170 }
22171
22172
22173 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj;
22175 wxPyApp *arg1 = (wxPyApp *) 0 ;
22176 PyObject *arg2 = (PyObject *) 0 ;
22177 PyObject *arg3 = (PyObject *) 0 ;
22178 PyObject * obj0 = 0 ;
22179 PyObject * obj1 = 0 ;
22180 PyObject * obj2 = 0 ;
22181 char *kwnames[] = {
22182 (char *) "self",(char *) "self",(char *) "_class", NULL
22183 };
22184
22185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22187 if (SWIG_arg_fail(1)) SWIG_fail;
22188 arg2 = obj1;
22189 arg3 = obj2;
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 (arg1)->_setCallbackInfo(arg2,arg3);
22193
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 Py_INCREF(Py_None); resultobj = Py_None;
22198 return resultobj;
22199 fail:
22200 return NULL;
22201 }
22202
22203
22204 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22205 PyObject *resultobj;
22206 wxPyApp *arg1 = (wxPyApp *) 0 ;
22207 wxString result;
22208 PyObject * obj0 = 0 ;
22209 char *kwnames[] = {
22210 (char *) "self", NULL
22211 };
22212
22213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22215 if (SWIG_arg_fail(1)) SWIG_fail;
22216 {
22217 PyThreadState* __tstate = wxPyBeginAllowThreads();
22218 result = ((wxPyApp const *)arg1)->GetAppName();
22219
22220 wxPyEndAllowThreads(__tstate);
22221 if (PyErr_Occurred()) SWIG_fail;
22222 }
22223 {
22224 #if wxUSE_UNICODE
22225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22226 #else
22227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22228 #endif
22229 }
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22237 PyObject *resultobj;
22238 wxPyApp *arg1 = (wxPyApp *) 0 ;
22239 wxString *arg2 = 0 ;
22240 bool temp2 = false ;
22241 PyObject * obj0 = 0 ;
22242 PyObject * obj1 = 0 ;
22243 char *kwnames[] = {
22244 (char *) "self",(char *) "name", NULL
22245 };
22246
22247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22249 if (SWIG_arg_fail(1)) SWIG_fail;
22250 {
22251 arg2 = wxString_in_helper(obj1);
22252 if (arg2 == NULL) SWIG_fail;
22253 temp2 = true;
22254 }
22255 {
22256 PyThreadState* __tstate = wxPyBeginAllowThreads();
22257 (arg1)->SetAppName((wxString const &)*arg2);
22258
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 Py_INCREF(Py_None); resultobj = Py_None;
22263 {
22264 if (temp2)
22265 delete arg2;
22266 }
22267 return resultobj;
22268 fail:
22269 {
22270 if (temp2)
22271 delete arg2;
22272 }
22273 return NULL;
22274 }
22275
22276
22277 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22278 PyObject *resultobj;
22279 wxPyApp *arg1 = (wxPyApp *) 0 ;
22280 wxString result;
22281 PyObject * obj0 = 0 ;
22282 char *kwnames[] = {
22283 (char *) "self", NULL
22284 };
22285
22286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(1)) SWIG_fail;
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 result = ((wxPyApp const *)arg1)->GetClassName();
22292
22293 wxPyEndAllowThreads(__tstate);
22294 if (PyErr_Occurred()) SWIG_fail;
22295 }
22296 {
22297 #if wxUSE_UNICODE
22298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22299 #else
22300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22301 #endif
22302 }
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22310 PyObject *resultobj;
22311 wxPyApp *arg1 = (wxPyApp *) 0 ;
22312 wxString *arg2 = 0 ;
22313 bool temp2 = false ;
22314 PyObject * obj0 = 0 ;
22315 PyObject * obj1 = 0 ;
22316 char *kwnames[] = {
22317 (char *) "self",(char *) "name", NULL
22318 };
22319
22320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22322 if (SWIG_arg_fail(1)) SWIG_fail;
22323 {
22324 arg2 = wxString_in_helper(obj1);
22325 if (arg2 == NULL) SWIG_fail;
22326 temp2 = true;
22327 }
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 (arg1)->SetClassName((wxString const &)*arg2);
22331
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 Py_INCREF(Py_None); resultobj = Py_None;
22336 {
22337 if (temp2)
22338 delete arg2;
22339 }
22340 return resultobj;
22341 fail:
22342 {
22343 if (temp2)
22344 delete arg2;
22345 }
22346 return NULL;
22347 }
22348
22349
22350 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22351 PyObject *resultobj;
22352 wxPyApp *arg1 = (wxPyApp *) 0 ;
22353 wxString *result;
22354 PyObject * obj0 = 0 ;
22355 char *kwnames[] = {
22356 (char *) "self", NULL
22357 };
22358
22359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22361 if (SWIG_arg_fail(1)) SWIG_fail;
22362 {
22363 PyThreadState* __tstate = wxPyBeginAllowThreads();
22364 {
22365 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22366 result = (wxString *) &_result_ref;
22367 }
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 {
22373 #if wxUSE_UNICODE
22374 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22375 #else
22376 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22377 #endif
22378 }
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22386 PyObject *resultobj;
22387 wxPyApp *arg1 = (wxPyApp *) 0 ;
22388 wxString *arg2 = 0 ;
22389 bool temp2 = false ;
22390 PyObject * obj0 = 0 ;
22391 PyObject * obj1 = 0 ;
22392 char *kwnames[] = {
22393 (char *) "self",(char *) "name", NULL
22394 };
22395
22396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22398 if (SWIG_arg_fail(1)) SWIG_fail;
22399 {
22400 arg2 = wxString_in_helper(obj1);
22401 if (arg2 == NULL) SWIG_fail;
22402 temp2 = true;
22403 }
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 (arg1)->SetVendorName((wxString const &)*arg2);
22407
22408 wxPyEndAllowThreads(__tstate);
22409 if (PyErr_Occurred()) SWIG_fail;
22410 }
22411 Py_INCREF(Py_None); resultobj = Py_None;
22412 {
22413 if (temp2)
22414 delete arg2;
22415 }
22416 return resultobj;
22417 fail:
22418 {
22419 if (temp2)
22420 delete arg2;
22421 }
22422 return NULL;
22423 }
22424
22425
22426 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22427 PyObject *resultobj;
22428 wxPyApp *arg1 = (wxPyApp *) 0 ;
22429 wxAppTraits *result;
22430 PyObject * obj0 = 0 ;
22431 char *kwnames[] = {
22432 (char *) "self", NULL
22433 };
22434
22435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22437 if (SWIG_arg_fail(1)) SWIG_fail;
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = (wxAppTraits *)(arg1)->GetTraits();
22441
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22446 return resultobj;
22447 fail:
22448 return NULL;
22449 }
22450
22451
22452 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22453 PyObject *resultobj;
22454 wxPyApp *arg1 = (wxPyApp *) 0 ;
22455 PyObject * obj0 = 0 ;
22456 char *kwnames[] = {
22457 (char *) "self", NULL
22458 };
22459
22460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22462 if (SWIG_arg_fail(1)) SWIG_fail;
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 (arg1)->ProcessPendingEvents();
22466
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 Py_INCREF(Py_None); resultobj = Py_None;
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22478 PyObject *resultobj;
22479 wxPyApp *arg1 = (wxPyApp *) 0 ;
22480 bool arg2 = (bool) false ;
22481 bool result;
22482 PyObject * obj0 = 0 ;
22483 PyObject * obj1 = 0 ;
22484 char *kwnames[] = {
22485 (char *) "self",(char *) "onlyIfNeeded", NULL
22486 };
22487
22488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22490 if (SWIG_arg_fail(1)) SWIG_fail;
22491 if (obj1) {
22492 {
22493 arg2 = (bool)(SWIG_As_bool(obj1));
22494 if (SWIG_arg_fail(2)) SWIG_fail;
22495 }
22496 }
22497 {
22498 PyThreadState* __tstate = wxPyBeginAllowThreads();
22499 result = (bool)(arg1)->Yield(arg2);
22500
22501 wxPyEndAllowThreads(__tstate);
22502 if (PyErr_Occurred()) SWIG_fail;
22503 }
22504 {
22505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22506 }
22507 return resultobj;
22508 fail:
22509 return NULL;
22510 }
22511
22512
22513 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22514 PyObject *resultobj;
22515 wxPyApp *arg1 = (wxPyApp *) 0 ;
22516 PyObject * obj0 = 0 ;
22517 char *kwnames[] = {
22518 (char *) "self", NULL
22519 };
22520
22521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22523 if (SWIG_arg_fail(1)) SWIG_fail;
22524 {
22525 PyThreadState* __tstate = wxPyBeginAllowThreads();
22526 (arg1)->WakeUpIdle();
22527
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 Py_INCREF(Py_None); resultobj = Py_None;
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj;
22540 bool result;
22541 char *kwnames[] = {
22542 NULL
22543 };
22544
22545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 result = (bool)wxPyApp::IsMainLoopRunning();
22549
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 {
22554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22555 }
22556 return resultobj;
22557 fail:
22558 return NULL;
22559 }
22560
22561
22562 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22563 PyObject *resultobj;
22564 wxPyApp *arg1 = (wxPyApp *) 0 ;
22565 int result;
22566 PyObject * obj0 = 0 ;
22567 char *kwnames[] = {
22568 (char *) "self", NULL
22569 };
22570
22571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22573 if (SWIG_arg_fail(1)) SWIG_fail;
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 result = (int)(arg1)->MainLoop();
22577
22578 wxPyEndAllowThreads(__tstate);
22579 if (PyErr_Occurred()) SWIG_fail;
22580 }
22581 {
22582 resultobj = SWIG_From_int((int)(result));
22583 }
22584 return resultobj;
22585 fail:
22586 return NULL;
22587 }
22588
22589
22590 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22591 PyObject *resultobj;
22592 wxPyApp *arg1 = (wxPyApp *) 0 ;
22593 PyObject * obj0 = 0 ;
22594 char *kwnames[] = {
22595 (char *) "self", NULL
22596 };
22597
22598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22600 if (SWIG_arg_fail(1)) SWIG_fail;
22601 {
22602 PyThreadState* __tstate = wxPyBeginAllowThreads();
22603 (arg1)->Exit();
22604
22605 wxPyEndAllowThreads(__tstate);
22606 if (PyErr_Occurred()) SWIG_fail;
22607 }
22608 Py_INCREF(Py_None); resultobj = Py_None;
22609 return resultobj;
22610 fail:
22611 return NULL;
22612 }
22613
22614
22615 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22616 PyObject *resultobj;
22617 wxPyApp *arg1 = (wxPyApp *) 0 ;
22618 PyObject * obj0 = 0 ;
22619 char *kwnames[] = {
22620 (char *) "self", NULL
22621 };
22622
22623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22625 if (SWIG_arg_fail(1)) SWIG_fail;
22626 {
22627 PyThreadState* __tstate = wxPyBeginAllowThreads();
22628 (arg1)->ExitMainLoop();
22629
22630 wxPyEndAllowThreads(__tstate);
22631 if (PyErr_Occurred()) SWIG_fail;
22632 }
22633 Py_INCREF(Py_None); resultobj = Py_None;
22634 return resultobj;
22635 fail:
22636 return NULL;
22637 }
22638
22639
22640 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22641 PyObject *resultobj;
22642 wxPyApp *arg1 = (wxPyApp *) 0 ;
22643 bool result;
22644 PyObject * obj0 = 0 ;
22645 char *kwnames[] = {
22646 (char *) "self", NULL
22647 };
22648
22649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22651 if (SWIG_arg_fail(1)) SWIG_fail;
22652 {
22653 PyThreadState* __tstate = wxPyBeginAllowThreads();
22654 result = (bool)(arg1)->Pending();
22655
22656 wxPyEndAllowThreads(__tstate);
22657 if (PyErr_Occurred()) SWIG_fail;
22658 }
22659 {
22660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22661 }
22662 return resultobj;
22663 fail:
22664 return NULL;
22665 }
22666
22667
22668 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22669 PyObject *resultobj;
22670 wxPyApp *arg1 = (wxPyApp *) 0 ;
22671 bool result;
22672 PyObject * obj0 = 0 ;
22673 char *kwnames[] = {
22674 (char *) "self", NULL
22675 };
22676
22677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22679 if (SWIG_arg_fail(1)) SWIG_fail;
22680 {
22681 PyThreadState* __tstate = wxPyBeginAllowThreads();
22682 result = (bool)(arg1)->Dispatch();
22683
22684 wxPyEndAllowThreads(__tstate);
22685 if (PyErr_Occurred()) SWIG_fail;
22686 }
22687 {
22688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22689 }
22690 return resultobj;
22691 fail:
22692 return NULL;
22693 }
22694
22695
22696 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22697 PyObject *resultobj;
22698 wxPyApp *arg1 = (wxPyApp *) 0 ;
22699 bool result;
22700 PyObject * obj0 = 0 ;
22701 char *kwnames[] = {
22702 (char *) "self", NULL
22703 };
22704
22705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22707 if (SWIG_arg_fail(1)) SWIG_fail;
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 result = (bool)(arg1)->ProcessIdle();
22711
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 {
22716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22717 }
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22725 PyObject *resultobj;
22726 wxPyApp *arg1 = (wxPyApp *) 0 ;
22727 wxWindow *arg2 = (wxWindow *) 0 ;
22728 wxIdleEvent *arg3 = 0 ;
22729 bool result;
22730 PyObject * obj0 = 0 ;
22731 PyObject * obj1 = 0 ;
22732 PyObject * obj2 = 0 ;
22733 char *kwnames[] = {
22734 (char *) "self",(char *) "win",(char *) "event", NULL
22735 };
22736
22737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22739 if (SWIG_arg_fail(1)) SWIG_fail;
22740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22741 if (SWIG_arg_fail(2)) SWIG_fail;
22742 {
22743 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22744 if (SWIG_arg_fail(3)) SWIG_fail;
22745 if (arg3 == NULL) {
22746 SWIG_null_ref("wxIdleEvent");
22747 }
22748 if (SWIG_arg_fail(3)) SWIG_fail;
22749 }
22750 {
22751 PyThreadState* __tstate = wxPyBeginAllowThreads();
22752 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22753
22754 wxPyEndAllowThreads(__tstate);
22755 if (PyErr_Occurred()) SWIG_fail;
22756 }
22757 {
22758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22759 }
22760 return resultobj;
22761 fail:
22762 return NULL;
22763 }
22764
22765
22766 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22767 PyObject *resultobj;
22768 wxPyApp *arg1 = (wxPyApp *) 0 ;
22769 bool result;
22770 PyObject * obj0 = 0 ;
22771 char *kwnames[] = {
22772 (char *) "self", NULL
22773 };
22774
22775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22777 if (SWIG_arg_fail(1)) SWIG_fail;
22778 {
22779 PyThreadState* __tstate = wxPyBeginAllowThreads();
22780 result = (bool)((wxPyApp const *)arg1)->IsActive();
22781
22782 wxPyEndAllowThreads(__tstate);
22783 if (PyErr_Occurred()) SWIG_fail;
22784 }
22785 {
22786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22787 }
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22795 PyObject *resultobj;
22796 wxPyApp *arg1 = (wxPyApp *) 0 ;
22797 wxWindow *arg2 = (wxWindow *) 0 ;
22798 PyObject * obj0 = 0 ;
22799 PyObject * obj1 = 0 ;
22800 char *kwnames[] = {
22801 (char *) "self",(char *) "win", NULL
22802 };
22803
22804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22808 if (SWIG_arg_fail(2)) SWIG_fail;
22809 {
22810 PyThreadState* __tstate = wxPyBeginAllowThreads();
22811 (arg1)->SetTopWindow(arg2);
22812
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 Py_INCREF(Py_None); resultobj = Py_None;
22817 return resultobj;
22818 fail:
22819 return NULL;
22820 }
22821
22822
22823 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22824 PyObject *resultobj;
22825 wxPyApp *arg1 = (wxPyApp *) 0 ;
22826 wxWindow *result;
22827 PyObject * obj0 = 0 ;
22828 char *kwnames[] = {
22829 (char *) "self", NULL
22830 };
22831
22832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22834 if (SWIG_arg_fail(1)) SWIG_fail;
22835 {
22836 PyThreadState* __tstate = wxPyBeginAllowThreads();
22837 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22838
22839 wxPyEndAllowThreads(__tstate);
22840 if (PyErr_Occurred()) SWIG_fail;
22841 }
22842 {
22843 resultobj = wxPyMake_wxObject(result, 0);
22844 }
22845 return resultobj;
22846 fail:
22847 return NULL;
22848 }
22849
22850
22851 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22852 PyObject *resultobj;
22853 wxPyApp *arg1 = (wxPyApp *) 0 ;
22854 bool arg2 ;
22855 PyObject * obj0 = 0 ;
22856 PyObject * obj1 = 0 ;
22857 char *kwnames[] = {
22858 (char *) "self",(char *) "flag", NULL
22859 };
22860
22861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22863 if (SWIG_arg_fail(1)) SWIG_fail;
22864 {
22865 arg2 = (bool)(SWIG_As_bool(obj1));
22866 if (SWIG_arg_fail(2)) SWIG_fail;
22867 }
22868 {
22869 PyThreadState* __tstate = wxPyBeginAllowThreads();
22870 (arg1)->SetExitOnFrameDelete(arg2);
22871
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 Py_INCREF(Py_None); resultobj = Py_None;
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22883 PyObject *resultobj;
22884 wxPyApp *arg1 = (wxPyApp *) 0 ;
22885 bool result;
22886 PyObject * obj0 = 0 ;
22887 char *kwnames[] = {
22888 (char *) "self", NULL
22889 };
22890
22891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22893 if (SWIG_arg_fail(1)) SWIG_fail;
22894 {
22895 PyThreadState* __tstate = wxPyBeginAllowThreads();
22896 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22897
22898 wxPyEndAllowThreads(__tstate);
22899 if (PyErr_Occurred()) SWIG_fail;
22900 }
22901 {
22902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22903 }
22904 return resultobj;
22905 fail:
22906 return NULL;
22907 }
22908
22909
22910 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22911 PyObject *resultobj;
22912 wxPyApp *arg1 = (wxPyApp *) 0 ;
22913 bool arg2 ;
22914 PyObject * obj0 = 0 ;
22915 PyObject * obj1 = 0 ;
22916 char *kwnames[] = {
22917 (char *) "self",(char *) "flag", NULL
22918 };
22919
22920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22922 if (SWIG_arg_fail(1)) SWIG_fail;
22923 {
22924 arg2 = (bool)(SWIG_As_bool(obj1));
22925 if (SWIG_arg_fail(2)) SWIG_fail;
22926 }
22927 {
22928 PyThreadState* __tstate = wxPyBeginAllowThreads();
22929 (arg1)->SetUseBestVisual(arg2);
22930
22931 wxPyEndAllowThreads(__tstate);
22932 if (PyErr_Occurred()) SWIG_fail;
22933 }
22934 Py_INCREF(Py_None); resultobj = Py_None;
22935 return resultobj;
22936 fail:
22937 return NULL;
22938 }
22939
22940
22941 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22942 PyObject *resultobj;
22943 wxPyApp *arg1 = (wxPyApp *) 0 ;
22944 bool result;
22945 PyObject * obj0 = 0 ;
22946 char *kwnames[] = {
22947 (char *) "self", NULL
22948 };
22949
22950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22952 if (SWIG_arg_fail(1)) SWIG_fail;
22953 {
22954 PyThreadState* __tstate = wxPyBeginAllowThreads();
22955 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22956
22957 wxPyEndAllowThreads(__tstate);
22958 if (PyErr_Occurred()) SWIG_fail;
22959 }
22960 {
22961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22962 }
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22970 PyObject *resultobj;
22971 wxPyApp *arg1 = (wxPyApp *) 0 ;
22972 int arg2 ;
22973 PyObject * obj0 = 0 ;
22974 PyObject * obj1 = 0 ;
22975 char *kwnames[] = {
22976 (char *) "self",(char *) "mode", NULL
22977 };
22978
22979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22981 if (SWIG_arg_fail(1)) SWIG_fail;
22982 {
22983 arg2 = (int)(SWIG_As_int(obj1));
22984 if (SWIG_arg_fail(2)) SWIG_fail;
22985 }
22986 {
22987 PyThreadState* __tstate = wxPyBeginAllowThreads();
22988 (arg1)->SetPrintMode(arg2);
22989
22990 wxPyEndAllowThreads(__tstate);
22991 if (PyErr_Occurred()) SWIG_fail;
22992 }
22993 Py_INCREF(Py_None); resultobj = Py_None;
22994 return resultobj;
22995 fail:
22996 return NULL;
22997 }
22998
22999
23000 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23001 PyObject *resultobj;
23002 wxPyApp *arg1 = (wxPyApp *) 0 ;
23003 int result;
23004 PyObject * obj0 = 0 ;
23005 char *kwnames[] = {
23006 (char *) "self", NULL
23007 };
23008
23009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23011 if (SWIG_arg_fail(1)) SWIG_fail;
23012 {
23013 PyThreadState* __tstate = wxPyBeginAllowThreads();
23014 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23015
23016 wxPyEndAllowThreads(__tstate);
23017 if (PyErr_Occurred()) SWIG_fail;
23018 }
23019 {
23020 resultobj = SWIG_From_int((int)(result));
23021 }
23022 return resultobj;
23023 fail:
23024 return NULL;
23025 }
23026
23027
23028 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23029 PyObject *resultobj;
23030 wxPyApp *arg1 = (wxPyApp *) 0 ;
23031 int arg2 ;
23032 PyObject * obj0 = 0 ;
23033 PyObject * obj1 = 0 ;
23034 char *kwnames[] = {
23035 (char *) "self",(char *) "mode", NULL
23036 };
23037
23038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23040 if (SWIG_arg_fail(1)) SWIG_fail;
23041 {
23042 arg2 = (int)(SWIG_As_int(obj1));
23043 if (SWIG_arg_fail(2)) SWIG_fail;
23044 }
23045 {
23046 PyThreadState* __tstate = wxPyBeginAllowThreads();
23047 (arg1)->SetAssertMode(arg2);
23048
23049 wxPyEndAllowThreads(__tstate);
23050 if (PyErr_Occurred()) SWIG_fail;
23051 }
23052 Py_INCREF(Py_None); resultobj = Py_None;
23053 return resultobj;
23054 fail:
23055 return NULL;
23056 }
23057
23058
23059 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23060 PyObject *resultobj;
23061 wxPyApp *arg1 = (wxPyApp *) 0 ;
23062 int result;
23063 PyObject * obj0 = 0 ;
23064 char *kwnames[] = {
23065 (char *) "self", NULL
23066 };
23067
23068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23070 if (SWIG_arg_fail(1)) SWIG_fail;
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 result = (int)(arg1)->GetAssertMode();
23074
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 {
23079 resultobj = SWIG_From_int((int)(result));
23080 }
23081 return resultobj;
23082 fail:
23083 return NULL;
23084 }
23085
23086
23087 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23088 PyObject *resultobj;
23089 bool result;
23090 char *kwnames[] = {
23091 NULL
23092 };
23093
23094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23098
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 {
23103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23104 }
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23112 PyObject *resultobj;
23113 long result;
23114 char *kwnames[] = {
23115 NULL
23116 };
23117
23118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 result = (long)wxPyApp::GetMacAboutMenuItemId();
23122
23123 wxPyEndAllowThreads(__tstate);
23124 if (PyErr_Occurred()) SWIG_fail;
23125 }
23126 {
23127 resultobj = SWIG_From_long((long)(result));
23128 }
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj;
23137 long result;
23138 char *kwnames[] = {
23139 NULL
23140 };
23141
23142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23143 {
23144 PyThreadState* __tstate = wxPyBeginAllowThreads();
23145 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23146
23147 wxPyEndAllowThreads(__tstate);
23148 if (PyErr_Occurred()) SWIG_fail;
23149 }
23150 {
23151 resultobj = SWIG_From_long((long)(result));
23152 }
23153 return resultobj;
23154 fail:
23155 return NULL;
23156 }
23157
23158
23159 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23160 PyObject *resultobj;
23161 long result;
23162 char *kwnames[] = {
23163 NULL
23164 };
23165
23166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23167 {
23168 PyThreadState* __tstate = wxPyBeginAllowThreads();
23169 result = (long)wxPyApp::GetMacExitMenuItemId();
23170
23171 wxPyEndAllowThreads(__tstate);
23172 if (PyErr_Occurred()) SWIG_fail;
23173 }
23174 {
23175 resultobj = SWIG_From_long((long)(result));
23176 }
23177 return resultobj;
23178 fail:
23179 return NULL;
23180 }
23181
23182
23183 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23184 PyObject *resultobj;
23185 wxString result;
23186 char *kwnames[] = {
23187 NULL
23188 };
23189
23190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23191 {
23192 PyThreadState* __tstate = wxPyBeginAllowThreads();
23193 result = wxPyApp::GetMacHelpMenuTitleName();
23194
23195 wxPyEndAllowThreads(__tstate);
23196 if (PyErr_Occurred()) SWIG_fail;
23197 }
23198 {
23199 #if wxUSE_UNICODE
23200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23201 #else
23202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23203 #endif
23204 }
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23212 PyObject *resultobj;
23213 bool arg1 ;
23214 PyObject * obj0 = 0 ;
23215 char *kwnames[] = {
23216 (char *) "val", NULL
23217 };
23218
23219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23220 {
23221 arg1 = (bool)(SWIG_As_bool(obj0));
23222 if (SWIG_arg_fail(1)) SWIG_fail;
23223 }
23224 {
23225 PyThreadState* __tstate = wxPyBeginAllowThreads();
23226 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23227
23228 wxPyEndAllowThreads(__tstate);
23229 if (PyErr_Occurred()) SWIG_fail;
23230 }
23231 Py_INCREF(Py_None); resultobj = Py_None;
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23239 PyObject *resultobj;
23240 long arg1 ;
23241 PyObject * obj0 = 0 ;
23242 char *kwnames[] = {
23243 (char *) "val", NULL
23244 };
23245
23246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23247 {
23248 arg1 = (long)(SWIG_As_long(obj0));
23249 if (SWIG_arg_fail(1)) SWIG_fail;
23250 }
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 wxPyApp::SetMacAboutMenuItemId(arg1);
23254
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 Py_INCREF(Py_None); resultobj = Py_None;
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23266 PyObject *resultobj;
23267 long arg1 ;
23268 PyObject * obj0 = 0 ;
23269 char *kwnames[] = {
23270 (char *) "val", NULL
23271 };
23272
23273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23274 {
23275 arg1 = (long)(SWIG_As_long(obj0));
23276 if (SWIG_arg_fail(1)) SWIG_fail;
23277 }
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23281
23282 wxPyEndAllowThreads(__tstate);
23283 if (PyErr_Occurred()) SWIG_fail;
23284 }
23285 Py_INCREF(Py_None); resultobj = Py_None;
23286 return resultobj;
23287 fail:
23288 return NULL;
23289 }
23290
23291
23292 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23293 PyObject *resultobj;
23294 long arg1 ;
23295 PyObject * obj0 = 0 ;
23296 char *kwnames[] = {
23297 (char *) "val", NULL
23298 };
23299
23300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23301 {
23302 arg1 = (long)(SWIG_As_long(obj0));
23303 if (SWIG_arg_fail(1)) SWIG_fail;
23304 }
23305 {
23306 PyThreadState* __tstate = wxPyBeginAllowThreads();
23307 wxPyApp::SetMacExitMenuItemId(arg1);
23308
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 Py_INCREF(Py_None); resultobj = Py_None;
23313 return resultobj;
23314 fail:
23315 return NULL;
23316 }
23317
23318
23319 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23320 PyObject *resultobj;
23321 wxString *arg1 = 0 ;
23322 bool temp1 = false ;
23323 PyObject * obj0 = 0 ;
23324 char *kwnames[] = {
23325 (char *) "val", NULL
23326 };
23327
23328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23329 {
23330 arg1 = wxString_in_helper(obj0);
23331 if (arg1 == NULL) SWIG_fail;
23332 temp1 = true;
23333 }
23334 {
23335 PyThreadState* __tstate = wxPyBeginAllowThreads();
23336 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23337
23338 wxPyEndAllowThreads(__tstate);
23339 if (PyErr_Occurred()) SWIG_fail;
23340 }
23341 Py_INCREF(Py_None); resultobj = Py_None;
23342 {
23343 if (temp1)
23344 delete arg1;
23345 }
23346 return resultobj;
23347 fail:
23348 {
23349 if (temp1)
23350 delete arg1;
23351 }
23352 return NULL;
23353 }
23354
23355
23356 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23357 PyObject *resultobj;
23358 wxPyApp *arg1 = (wxPyApp *) 0 ;
23359 PyObject * obj0 = 0 ;
23360 char *kwnames[] = {
23361 (char *) "self", NULL
23362 };
23363
23364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(1)) SWIG_fail;
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 (arg1)->_BootstrapApp();
23370
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 Py_INCREF(Py_None); resultobj = Py_None;
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj;
23383 int result;
23384 char *kwnames[] = {
23385 NULL
23386 };
23387
23388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = (int)PyApp_GetComCtl32Version();
23392
23393 wxPyEndAllowThreads(__tstate);
23394 if (PyErr_Occurred()) SWIG_fail;
23395 }
23396 {
23397 resultobj = SWIG_From_int((int)(result));
23398 }
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23406 PyObject *obj;
23407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23408 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23409 Py_INCREF(obj);
23410 return Py_BuildValue((char *)"");
23411 }
23412 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23413 PyObject *resultobj;
23414 char *kwnames[] = {
23415 NULL
23416 };
23417
23418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 wxExit();
23422
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 Py_INCREF(Py_None); resultobj = Py_None;
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj;
23435 bool result;
23436 char *kwnames[] = {
23437 NULL
23438 };
23439
23440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23441 {
23442 PyThreadState* __tstate = wxPyBeginAllowThreads();
23443 result = (bool)wxYield();
23444
23445 wxPyEndAllowThreads(__tstate);
23446 if (PyErr_Occurred()) SWIG_fail;
23447 }
23448 {
23449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23450 }
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23458 PyObject *resultobj;
23459 bool result;
23460 char *kwnames[] = {
23461 NULL
23462 };
23463
23464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23465 {
23466 PyThreadState* __tstate = wxPyBeginAllowThreads();
23467 result = (bool)wxYieldIfNeeded();
23468
23469 wxPyEndAllowThreads(__tstate);
23470 if (PyErr_Occurred()) SWIG_fail;
23471 }
23472 {
23473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23474 }
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23482 PyObject *resultobj;
23483 wxWindow *arg1 = (wxWindow *) NULL ;
23484 bool arg2 = (bool) false ;
23485 bool result;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 char *kwnames[] = {
23489 (char *) "win",(char *) "onlyIfNeeded", NULL
23490 };
23491
23492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23493 if (obj0) {
23494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23495 if (SWIG_arg_fail(1)) SWIG_fail;
23496 }
23497 if (obj1) {
23498 {
23499 arg2 = (bool)(SWIG_As_bool(obj1));
23500 if (SWIG_arg_fail(2)) SWIG_fail;
23501 }
23502 }
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 result = (bool)wxSafeYield(arg1,arg2);
23506
23507 wxPyEndAllowThreads(__tstate);
23508 if (PyErr_Occurred()) SWIG_fail;
23509 }
23510 {
23511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23512 }
23513 return resultobj;
23514 fail:
23515 return NULL;
23516 }
23517
23518
23519 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23520 PyObject *resultobj;
23521 char *kwnames[] = {
23522 NULL
23523 };
23524
23525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 wxWakeUpIdle();
23529
23530 wxPyEndAllowThreads(__tstate);
23531 if (PyErr_Occurred()) SWIG_fail;
23532 }
23533 Py_INCREF(Py_None); resultobj = Py_None;
23534 return resultobj;
23535 fail:
23536 return NULL;
23537 }
23538
23539
23540 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23541 PyObject *resultobj;
23542 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23543 wxEvent *arg2 = 0 ;
23544 PyObject * obj0 = 0 ;
23545 PyObject * obj1 = 0 ;
23546 char *kwnames[] = {
23547 (char *) "dest",(char *) "event", NULL
23548 };
23549
23550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23552 if (SWIG_arg_fail(1)) SWIG_fail;
23553 {
23554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23555 if (SWIG_arg_fail(2)) SWIG_fail;
23556 if (arg2 == NULL) {
23557 SWIG_null_ref("wxEvent");
23558 }
23559 if (SWIG_arg_fail(2)) SWIG_fail;
23560 }
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 wxPostEvent(arg1,*arg2);
23564
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 Py_INCREF(Py_None); resultobj = Py_None;
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj;
23577 char *kwnames[] = {
23578 NULL
23579 };
23580
23581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23582 {
23583 PyThreadState* __tstate = wxPyBeginAllowThreads();
23584 wxApp_CleanUp();
23585
23586 wxPyEndAllowThreads(__tstate);
23587 if (PyErr_Occurred()) SWIG_fail;
23588 }
23589 Py_INCREF(Py_None); resultobj = Py_None;
23590 return resultobj;
23591 fail:
23592 return NULL;
23593 }
23594
23595
23596 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23597 PyObject *resultobj;
23598 wxPyApp *result;
23599 char *kwnames[] = {
23600 NULL
23601 };
23602
23603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = (wxPyApp *)wxPyGetApp();
23607
23608 wxPyEndAllowThreads(__tstate);
23609 if (PyErr_Occurred()) SWIG_fail;
23610 }
23611 {
23612 resultobj = wxPyMake_wxObject(result, 0);
23613 }
23614 return resultobj;
23615 fail:
23616 return NULL;
23617 }
23618
23619
23620 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23621 PyObject *resultobj;
23622 char *arg1 = (char *) 0 ;
23623 PyObject * obj0 = 0 ;
23624 char *kwnames[] = {
23625 (char *) "encoding", NULL
23626 };
23627
23628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23629 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23630 SWIG_arg_fail(1);SWIG_fail;
23631 }
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 wxSetDefaultPyEncoding((char const *)arg1);
23635
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 Py_INCREF(Py_None); resultobj = Py_None;
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23647 PyObject *resultobj;
23648 char *result;
23649 char *kwnames[] = {
23650 NULL
23651 };
23652
23653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23654 {
23655 PyThreadState* __tstate = wxPyBeginAllowThreads();
23656 result = (char *)wxGetDefaultPyEncoding();
23657
23658 wxPyEndAllowThreads(__tstate);
23659 if (PyErr_Occurred()) SWIG_fail;
23660 }
23661 resultobj = SWIG_FromCharPtr(result);
23662 return resultobj;
23663 fail:
23664 return NULL;
23665 }
23666
23667
23668 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj;
23670 wxEventLoop *result;
23671 char *kwnames[] = {
23672 NULL
23673 };
23674
23675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23676 {
23677 PyThreadState* __tstate = wxPyBeginAllowThreads();
23678 result = (wxEventLoop *)new wxEventLoop();
23679
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23691 PyObject *resultobj;
23692 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23693 PyObject * obj0 = 0 ;
23694 char *kwnames[] = {
23695 (char *) "self", NULL
23696 };
23697
23698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23700 if (SWIG_arg_fail(1)) SWIG_fail;
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 delete arg1;
23704
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 Py_INCREF(Py_None); resultobj = Py_None;
23709 return resultobj;
23710 fail:
23711 return NULL;
23712 }
23713
23714
23715 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23716 PyObject *resultobj;
23717 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23718 int result;
23719 PyObject * obj0 = 0 ;
23720 char *kwnames[] = {
23721 (char *) "self", NULL
23722 };
23723
23724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23726 if (SWIG_arg_fail(1)) SWIG_fail;
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (int)(arg1)->Run();
23730
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 {
23735 resultobj = SWIG_From_int((int)(result));
23736 }
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23744 PyObject *resultobj;
23745 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23746 int arg2 = (int) 0 ;
23747 PyObject * obj0 = 0 ;
23748 PyObject * obj1 = 0 ;
23749 char *kwnames[] = {
23750 (char *) "self",(char *) "rc", NULL
23751 };
23752
23753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23755 if (SWIG_arg_fail(1)) SWIG_fail;
23756 if (obj1) {
23757 {
23758 arg2 = (int)(SWIG_As_int(obj1));
23759 if (SWIG_arg_fail(2)) SWIG_fail;
23760 }
23761 }
23762 {
23763 PyThreadState* __tstate = wxPyBeginAllowThreads();
23764 (arg1)->Exit(arg2);
23765
23766 wxPyEndAllowThreads(__tstate);
23767 if (PyErr_Occurred()) SWIG_fail;
23768 }
23769 Py_INCREF(Py_None); resultobj = Py_None;
23770 return resultobj;
23771 fail:
23772 return NULL;
23773 }
23774
23775
23776 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23777 PyObject *resultobj;
23778 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23779 bool result;
23780 PyObject * obj0 = 0 ;
23781 char *kwnames[] = {
23782 (char *) "self", NULL
23783 };
23784
23785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23787 if (SWIG_arg_fail(1)) SWIG_fail;
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 result = (bool)((wxEventLoop const *)arg1)->Pending();
23791
23792 wxPyEndAllowThreads(__tstate);
23793 if (PyErr_Occurred()) SWIG_fail;
23794 }
23795 {
23796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23797 }
23798 return resultobj;
23799 fail:
23800 return NULL;
23801 }
23802
23803
23804 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj;
23806 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23807 bool result;
23808 PyObject * obj0 = 0 ;
23809 char *kwnames[] = {
23810 (char *) "self", NULL
23811 };
23812
23813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23815 if (SWIG_arg_fail(1)) SWIG_fail;
23816 {
23817 PyThreadState* __tstate = wxPyBeginAllowThreads();
23818 result = (bool)(arg1)->Dispatch();
23819
23820 wxPyEndAllowThreads(__tstate);
23821 if (PyErr_Occurred()) SWIG_fail;
23822 }
23823 {
23824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23825 }
23826 return resultobj;
23827 fail:
23828 return NULL;
23829 }
23830
23831
23832 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23833 PyObject *resultobj;
23834 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23835 bool result;
23836 PyObject * obj0 = 0 ;
23837 char *kwnames[] = {
23838 (char *) "self", NULL
23839 };
23840
23841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23843 if (SWIG_arg_fail(1)) SWIG_fail;
23844 {
23845 PyThreadState* __tstate = wxPyBeginAllowThreads();
23846 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23847
23848 wxPyEndAllowThreads(__tstate);
23849 if (PyErr_Occurred()) SWIG_fail;
23850 }
23851 {
23852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23853 }
23854 return resultobj;
23855 fail:
23856 return NULL;
23857 }
23858
23859
23860 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23861 PyObject *resultobj;
23862 wxEventLoop *result;
23863 char *kwnames[] = {
23864 NULL
23865 };
23866
23867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 result = (wxEventLoop *)wxEventLoop::GetActive();
23871
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj;
23884 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23885 PyObject * obj0 = 0 ;
23886 char *kwnames[] = {
23887 (char *) "loop", NULL
23888 };
23889
23890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23892 if (SWIG_arg_fail(1)) SWIG_fail;
23893 {
23894 PyThreadState* __tstate = wxPyBeginAllowThreads();
23895 wxEventLoop::SetActive(arg1);
23896
23897 wxPyEndAllowThreads(__tstate);
23898 if (PyErr_Occurred()) SWIG_fail;
23899 }
23900 Py_INCREF(Py_None); resultobj = Py_None;
23901 return resultobj;
23902 fail:
23903 return NULL;
23904 }
23905
23906
23907 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23908 PyObject *obj;
23909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23910 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23911 Py_INCREF(obj);
23912 return Py_BuildValue((char *)"");
23913 }
23914 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23915 PyObject *resultobj;
23916 int arg1 = (int) 0 ;
23917 int arg2 = (int) 0 ;
23918 int arg3 = (int) 0 ;
23919 wxAcceleratorEntry *result;
23920 PyObject * obj0 = 0 ;
23921 PyObject * obj1 = 0 ;
23922 PyObject * obj2 = 0 ;
23923 char *kwnames[] = {
23924 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23925 };
23926
23927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23928 if (obj0) {
23929 {
23930 arg1 = (int)(SWIG_As_int(obj0));
23931 if (SWIG_arg_fail(1)) SWIG_fail;
23932 }
23933 }
23934 if (obj1) {
23935 {
23936 arg2 = (int)(SWIG_As_int(obj1));
23937 if (SWIG_arg_fail(2)) SWIG_fail;
23938 }
23939 }
23940 if (obj2) {
23941 {
23942 arg3 = (int)(SWIG_As_int(obj2));
23943 if (SWIG_arg_fail(3)) SWIG_fail;
23944 }
23945 }
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23949
23950 wxPyEndAllowThreads(__tstate);
23951 if (PyErr_Occurred()) SWIG_fail;
23952 }
23953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23961 PyObject *resultobj;
23962 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23963 PyObject * obj0 = 0 ;
23964 char *kwnames[] = {
23965 (char *) "self", NULL
23966 };
23967
23968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23970 if (SWIG_arg_fail(1)) SWIG_fail;
23971 {
23972 PyThreadState* __tstate = wxPyBeginAllowThreads();
23973 delete arg1;
23974
23975 wxPyEndAllowThreads(__tstate);
23976 if (PyErr_Occurred()) SWIG_fail;
23977 }
23978 Py_INCREF(Py_None); resultobj = Py_None;
23979 return resultobj;
23980 fail:
23981 return NULL;
23982 }
23983
23984
23985 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23986 PyObject *resultobj;
23987 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23988 int arg2 ;
23989 int arg3 ;
23990 int arg4 ;
23991 PyObject * obj0 = 0 ;
23992 PyObject * obj1 = 0 ;
23993 PyObject * obj2 = 0 ;
23994 PyObject * obj3 = 0 ;
23995 char *kwnames[] = {
23996 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23997 };
23998
23999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24001 if (SWIG_arg_fail(1)) SWIG_fail;
24002 {
24003 arg2 = (int)(SWIG_As_int(obj1));
24004 if (SWIG_arg_fail(2)) SWIG_fail;
24005 }
24006 {
24007 arg3 = (int)(SWIG_As_int(obj2));
24008 if (SWIG_arg_fail(3)) SWIG_fail;
24009 }
24010 {
24011 arg4 = (int)(SWIG_As_int(obj3));
24012 if (SWIG_arg_fail(4)) SWIG_fail;
24013 }
24014 {
24015 PyThreadState* __tstate = wxPyBeginAllowThreads();
24016 (arg1)->Set(arg2,arg3,arg4);
24017
24018 wxPyEndAllowThreads(__tstate);
24019 if (PyErr_Occurred()) SWIG_fail;
24020 }
24021 Py_INCREF(Py_None); resultobj = Py_None;
24022 return resultobj;
24023 fail:
24024 return NULL;
24025 }
24026
24027
24028 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24029 PyObject *resultobj;
24030 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24031 int result;
24032 PyObject * obj0 = 0 ;
24033 char *kwnames[] = {
24034 (char *) "self", NULL
24035 };
24036
24037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24039 if (SWIG_arg_fail(1)) SWIG_fail;
24040 {
24041 PyThreadState* __tstate = wxPyBeginAllowThreads();
24042 result = (int)(arg1)->GetFlags();
24043
24044 wxPyEndAllowThreads(__tstate);
24045 if (PyErr_Occurred()) SWIG_fail;
24046 }
24047 {
24048 resultobj = SWIG_From_int((int)(result));
24049 }
24050 return resultobj;
24051 fail:
24052 return NULL;
24053 }
24054
24055
24056 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24057 PyObject *resultobj;
24058 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24059 int result;
24060 PyObject * obj0 = 0 ;
24061 char *kwnames[] = {
24062 (char *) "self", NULL
24063 };
24064
24065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24067 if (SWIG_arg_fail(1)) SWIG_fail;
24068 {
24069 PyThreadState* __tstate = wxPyBeginAllowThreads();
24070 result = (int)(arg1)->GetKeyCode();
24071
24072 wxPyEndAllowThreads(__tstate);
24073 if (PyErr_Occurred()) SWIG_fail;
24074 }
24075 {
24076 resultobj = SWIG_From_int((int)(result));
24077 }
24078 return resultobj;
24079 fail:
24080 return NULL;
24081 }
24082
24083
24084 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24085 PyObject *resultobj;
24086 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24087 int result;
24088 PyObject * obj0 = 0 ;
24089 char *kwnames[] = {
24090 (char *) "self", NULL
24091 };
24092
24093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24095 if (SWIG_arg_fail(1)) SWIG_fail;
24096 {
24097 PyThreadState* __tstate = wxPyBeginAllowThreads();
24098 result = (int)(arg1)->GetCommand();
24099
24100 wxPyEndAllowThreads(__tstate);
24101 if (PyErr_Occurred()) SWIG_fail;
24102 }
24103 {
24104 resultobj = SWIG_From_int((int)(result));
24105 }
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24113 PyObject *obj;
24114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24115 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24116 Py_INCREF(obj);
24117 return Py_BuildValue((char *)"");
24118 }
24119 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj;
24121 int arg1 ;
24122 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24123 wxAcceleratorTable *result;
24124 PyObject * obj0 = 0 ;
24125 char *kwnames[] = {
24126 (char *) "n", NULL
24127 };
24128
24129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24130 {
24131 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24132 if (arg2) arg1 = PyList_Size(obj0);
24133 else arg1 = 0;
24134 }
24135 {
24136 PyThreadState* __tstate = wxPyBeginAllowThreads();
24137 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24138
24139 wxPyEndAllowThreads(__tstate);
24140 if (PyErr_Occurred()) SWIG_fail;
24141 }
24142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24143 {
24144 delete [] arg2;
24145 }
24146 return resultobj;
24147 fail:
24148 {
24149 delete [] arg2;
24150 }
24151 return NULL;
24152 }
24153
24154
24155 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24156 PyObject *resultobj;
24157 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24158 PyObject * obj0 = 0 ;
24159 char *kwnames[] = {
24160 (char *) "self", NULL
24161 };
24162
24163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24165 if (SWIG_arg_fail(1)) SWIG_fail;
24166 {
24167 PyThreadState* __tstate = wxPyBeginAllowThreads();
24168 delete arg1;
24169
24170 wxPyEndAllowThreads(__tstate);
24171 if (PyErr_Occurred()) SWIG_fail;
24172 }
24173 Py_INCREF(Py_None); resultobj = Py_None;
24174 return resultobj;
24175 fail:
24176 return NULL;
24177 }
24178
24179
24180 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24181 PyObject *resultobj;
24182 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24183 bool result;
24184 PyObject * obj0 = 0 ;
24185 char *kwnames[] = {
24186 (char *) "self", NULL
24187 };
24188
24189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24191 if (SWIG_arg_fail(1)) SWIG_fail;
24192 {
24193 PyThreadState* __tstate = wxPyBeginAllowThreads();
24194 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24195
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 {
24200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24201 }
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24209 PyObject *obj;
24210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24211 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24212 Py_INCREF(obj);
24213 return Py_BuildValue((char *)"");
24214 }
24215 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24216 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24217 return 1;
24218 }
24219
24220
24221 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24222 PyObject *pyobj;
24223
24224 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24225 return pyobj;
24226 }
24227
24228
24229 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24230 PyObject *resultobj;
24231 wxString *arg1 = 0 ;
24232 wxAcceleratorEntry *result;
24233 bool temp1 = false ;
24234 PyObject * obj0 = 0 ;
24235 char *kwnames[] = {
24236 (char *) "label", NULL
24237 };
24238
24239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24240 {
24241 arg1 = wxString_in_helper(obj0);
24242 if (arg1 == NULL) SWIG_fail;
24243 temp1 = true;
24244 }
24245 {
24246 PyThreadState* __tstate = wxPyBeginAllowThreads();
24247 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24248
24249 wxPyEndAllowThreads(__tstate);
24250 if (PyErr_Occurred()) SWIG_fail;
24251 }
24252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24253 {
24254 if (temp1)
24255 delete arg1;
24256 }
24257 return resultobj;
24258 fail:
24259 {
24260 if (temp1)
24261 delete arg1;
24262 }
24263 return NULL;
24264 }
24265
24266
24267 static int _wrap_PanelNameStr_set(PyObject *) {
24268 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24269 return 1;
24270 }
24271
24272
24273 static PyObject *_wrap_PanelNameStr_get(void) {
24274 PyObject *pyobj;
24275
24276 {
24277 #if wxUSE_UNICODE
24278 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24279 #else
24280 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24281 #endif
24282 }
24283 return pyobj;
24284 }
24285
24286
24287 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24288 PyObject *resultobj;
24289 wxVisualAttributes *result;
24290 char *kwnames[] = {
24291 NULL
24292 };
24293
24294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24295 {
24296 PyThreadState* __tstate = wxPyBeginAllowThreads();
24297 result = (wxVisualAttributes *)new_wxVisualAttributes();
24298
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24310 PyObject *resultobj;
24311 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24312 PyObject * obj0 = 0 ;
24313 char *kwnames[] = {
24314 (char *) "self", NULL
24315 };
24316
24317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24319 if (SWIG_arg_fail(1)) SWIG_fail;
24320 {
24321 PyThreadState* __tstate = wxPyBeginAllowThreads();
24322 delete_wxVisualAttributes(arg1);
24323
24324 wxPyEndAllowThreads(__tstate);
24325 if (PyErr_Occurred()) SWIG_fail;
24326 }
24327 Py_INCREF(Py_None); resultobj = Py_None;
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj;
24336 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24337 wxFont *arg2 = (wxFont *) 0 ;
24338 PyObject * obj0 = 0 ;
24339 PyObject * obj1 = 0 ;
24340 char *kwnames[] = {
24341 (char *) "self",(char *) "font", NULL
24342 };
24343
24344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24348 if (SWIG_arg_fail(2)) SWIG_fail;
24349 if (arg1) (arg1)->font = *arg2;
24350
24351 Py_INCREF(Py_None); resultobj = Py_None;
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj;
24360 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24361 wxFont *result;
24362 PyObject * obj0 = 0 ;
24363 char *kwnames[] = {
24364 (char *) "self", NULL
24365 };
24366
24367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24369 if (SWIG_arg_fail(1)) SWIG_fail;
24370 result = (wxFont *)& ((arg1)->font);
24371
24372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24380 PyObject *resultobj;
24381 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24382 wxColour *arg2 = (wxColour *) 0 ;
24383 PyObject * obj0 = 0 ;
24384 PyObject * obj1 = 0 ;
24385 char *kwnames[] = {
24386 (char *) "self",(char *) "colFg", NULL
24387 };
24388
24389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24391 if (SWIG_arg_fail(1)) SWIG_fail;
24392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24393 if (SWIG_arg_fail(2)) SWIG_fail;
24394 if (arg1) (arg1)->colFg = *arg2;
24395
24396 Py_INCREF(Py_None); resultobj = Py_None;
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24404 PyObject *resultobj;
24405 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24406 wxColour *result;
24407 PyObject * obj0 = 0 ;
24408 char *kwnames[] = {
24409 (char *) "self", NULL
24410 };
24411
24412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24414 if (SWIG_arg_fail(1)) SWIG_fail;
24415 result = (wxColour *)& ((arg1)->colFg);
24416
24417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24425 PyObject *resultobj;
24426 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24427 wxColour *arg2 = (wxColour *) 0 ;
24428 PyObject * obj0 = 0 ;
24429 PyObject * obj1 = 0 ;
24430 char *kwnames[] = {
24431 (char *) "self",(char *) "colBg", NULL
24432 };
24433
24434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24436 if (SWIG_arg_fail(1)) SWIG_fail;
24437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24438 if (SWIG_arg_fail(2)) SWIG_fail;
24439 if (arg1) (arg1)->colBg = *arg2;
24440
24441 Py_INCREF(Py_None); resultobj = Py_None;
24442 return resultobj;
24443 fail:
24444 return NULL;
24445 }
24446
24447
24448 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24449 PyObject *resultobj;
24450 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24451 wxColour *result;
24452 PyObject * obj0 = 0 ;
24453 char *kwnames[] = {
24454 (char *) "self", NULL
24455 };
24456
24457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24459 if (SWIG_arg_fail(1)) SWIG_fail;
24460 result = (wxColour *)& ((arg1)->colBg);
24461
24462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24470 PyObject *obj;
24471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24472 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24473 Py_INCREF(obj);
24474 return Py_BuildValue((char *)"");
24475 }
24476 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj;
24478 wxWindow *arg1 = (wxWindow *) 0 ;
24479 int arg2 = (int) (int)-1 ;
24480 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24481 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24482 wxSize const &arg4_defvalue = wxDefaultSize ;
24483 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24484 long arg5 = (long) 0 ;
24485 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24486 wxString *arg6 = (wxString *) &arg6_defvalue ;
24487 wxWindow *result;
24488 wxPoint temp3 ;
24489 wxSize temp4 ;
24490 bool temp6 = false ;
24491 PyObject * obj0 = 0 ;
24492 PyObject * obj1 = 0 ;
24493 PyObject * obj2 = 0 ;
24494 PyObject * obj3 = 0 ;
24495 PyObject * obj4 = 0 ;
24496 PyObject * obj5 = 0 ;
24497 char *kwnames[] = {
24498 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24499 };
24500
24501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24503 if (SWIG_arg_fail(1)) SWIG_fail;
24504 if (obj1) {
24505 {
24506 arg2 = (int const)(SWIG_As_int(obj1));
24507 if (SWIG_arg_fail(2)) SWIG_fail;
24508 }
24509 }
24510 if (obj2) {
24511 {
24512 arg3 = &temp3;
24513 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24514 }
24515 }
24516 if (obj3) {
24517 {
24518 arg4 = &temp4;
24519 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24520 }
24521 }
24522 if (obj4) {
24523 {
24524 arg5 = (long)(SWIG_As_long(obj4));
24525 if (SWIG_arg_fail(5)) SWIG_fail;
24526 }
24527 }
24528 if (obj5) {
24529 {
24530 arg6 = wxString_in_helper(obj5);
24531 if (arg6 == NULL) SWIG_fail;
24532 temp6 = true;
24533 }
24534 }
24535 {
24536 if (!wxPyCheckForApp()) SWIG_fail;
24537 PyThreadState* __tstate = wxPyBeginAllowThreads();
24538 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24539
24540 wxPyEndAllowThreads(__tstate);
24541 if (PyErr_Occurred()) SWIG_fail;
24542 }
24543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24544 {
24545 if (temp6)
24546 delete arg6;
24547 }
24548 return resultobj;
24549 fail:
24550 {
24551 if (temp6)
24552 delete arg6;
24553 }
24554 return NULL;
24555 }
24556
24557
24558 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24559 PyObject *resultobj;
24560 wxWindow *result;
24561 char *kwnames[] = {
24562 NULL
24563 };
24564
24565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24566 {
24567 if (!wxPyCheckForApp()) SWIG_fail;
24568 PyThreadState* __tstate = wxPyBeginAllowThreads();
24569 result = (wxWindow *)new wxWindow();
24570
24571 wxPyEndAllowThreads(__tstate);
24572 if (PyErr_Occurred()) SWIG_fail;
24573 }
24574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24582 PyObject *resultobj;
24583 wxWindow *arg1 = (wxWindow *) 0 ;
24584 wxWindow *arg2 = (wxWindow *) 0 ;
24585 int arg3 = (int) (int)-1 ;
24586 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24587 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24588 wxSize const &arg5_defvalue = wxDefaultSize ;
24589 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24590 long arg6 = (long) 0 ;
24591 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24592 wxString *arg7 = (wxString *) &arg7_defvalue ;
24593 bool result;
24594 wxPoint temp4 ;
24595 wxSize temp5 ;
24596 bool temp7 = false ;
24597 PyObject * obj0 = 0 ;
24598 PyObject * obj1 = 0 ;
24599 PyObject * obj2 = 0 ;
24600 PyObject * obj3 = 0 ;
24601 PyObject * obj4 = 0 ;
24602 PyObject * obj5 = 0 ;
24603 PyObject * obj6 = 0 ;
24604 char *kwnames[] = {
24605 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24606 };
24607
24608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24610 if (SWIG_arg_fail(1)) SWIG_fail;
24611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24612 if (SWIG_arg_fail(2)) SWIG_fail;
24613 if (obj2) {
24614 {
24615 arg3 = (int const)(SWIG_As_int(obj2));
24616 if (SWIG_arg_fail(3)) SWIG_fail;
24617 }
24618 }
24619 if (obj3) {
24620 {
24621 arg4 = &temp4;
24622 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24623 }
24624 }
24625 if (obj4) {
24626 {
24627 arg5 = &temp5;
24628 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24629 }
24630 }
24631 if (obj5) {
24632 {
24633 arg6 = (long)(SWIG_As_long(obj5));
24634 if (SWIG_arg_fail(6)) SWIG_fail;
24635 }
24636 }
24637 if (obj6) {
24638 {
24639 arg7 = wxString_in_helper(obj6);
24640 if (arg7 == NULL) SWIG_fail;
24641 temp7 = true;
24642 }
24643 }
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24647
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 {
24652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24653 }
24654 {
24655 if (temp7)
24656 delete arg7;
24657 }
24658 return resultobj;
24659 fail:
24660 {
24661 if (temp7)
24662 delete arg7;
24663 }
24664 return NULL;
24665 }
24666
24667
24668 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj;
24670 wxWindow *arg1 = (wxWindow *) 0 ;
24671 bool arg2 = (bool) false ;
24672 bool result;
24673 PyObject * obj0 = 0 ;
24674 PyObject * obj1 = 0 ;
24675 char *kwnames[] = {
24676 (char *) "self",(char *) "force", NULL
24677 };
24678
24679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24681 if (SWIG_arg_fail(1)) SWIG_fail;
24682 if (obj1) {
24683 {
24684 arg2 = (bool)(SWIG_As_bool(obj1));
24685 if (SWIG_arg_fail(2)) SWIG_fail;
24686 }
24687 }
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 result = (bool)(arg1)->Close(arg2);
24691
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 {
24696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24697 }
24698 return resultobj;
24699 fail:
24700 return NULL;
24701 }
24702
24703
24704 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24705 PyObject *resultobj;
24706 wxWindow *arg1 = (wxWindow *) 0 ;
24707 bool result;
24708 PyObject * obj0 = 0 ;
24709 char *kwnames[] = {
24710 (char *) "self", NULL
24711 };
24712
24713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24715 if (SWIG_arg_fail(1)) SWIG_fail;
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (bool)(arg1)->Destroy();
24719
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 {
24724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24725 }
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj;
24734 wxWindow *arg1 = (wxWindow *) 0 ;
24735 bool result;
24736 PyObject * obj0 = 0 ;
24737 char *kwnames[] = {
24738 (char *) "self", NULL
24739 };
24740
24741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24743 if (SWIG_arg_fail(1)) SWIG_fail;
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 result = (bool)(arg1)->DestroyChildren();
24747
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 {
24752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24753 }
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24761 PyObject *resultobj;
24762 wxWindow *arg1 = (wxWindow *) 0 ;
24763 bool result;
24764 PyObject * obj0 = 0 ;
24765 char *kwnames[] = {
24766 (char *) "self", NULL
24767 };
24768
24769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24771 if (SWIG_arg_fail(1)) SWIG_fail;
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24775
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 wxWindow *arg1 = (wxWindow *) 0 ;
24791 wxString *arg2 = 0 ;
24792 bool temp2 = false ;
24793 PyObject * obj0 = 0 ;
24794 PyObject * obj1 = 0 ;
24795 char *kwnames[] = {
24796 (char *) "self",(char *) "title", NULL
24797 };
24798
24799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24801 if (SWIG_arg_fail(1)) SWIG_fail;
24802 {
24803 arg2 = wxString_in_helper(obj1);
24804 if (arg2 == NULL) SWIG_fail;
24805 temp2 = true;
24806 }
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 (arg1)->SetTitle((wxString const &)*arg2);
24810
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 Py_INCREF(Py_None); resultobj = Py_None;
24815 {
24816 if (temp2)
24817 delete arg2;
24818 }
24819 return resultobj;
24820 fail:
24821 {
24822 if (temp2)
24823 delete arg2;
24824 }
24825 return NULL;
24826 }
24827
24828
24829 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj;
24831 wxWindow *arg1 = (wxWindow *) 0 ;
24832 wxString result;
24833 PyObject * obj0 = 0 ;
24834 char *kwnames[] = {
24835 (char *) "self", NULL
24836 };
24837
24838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24840 if (SWIG_arg_fail(1)) SWIG_fail;
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 result = ((wxWindow const *)arg1)->GetTitle();
24844
24845 wxPyEndAllowThreads(__tstate);
24846 if (PyErr_Occurred()) SWIG_fail;
24847 }
24848 {
24849 #if wxUSE_UNICODE
24850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24851 #else
24852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24853 #endif
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24862 PyObject *resultobj;
24863 wxWindow *arg1 = (wxWindow *) 0 ;
24864 wxString *arg2 = 0 ;
24865 bool temp2 = false ;
24866 PyObject * obj0 = 0 ;
24867 PyObject * obj1 = 0 ;
24868 char *kwnames[] = {
24869 (char *) "self",(char *) "label", NULL
24870 };
24871
24872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24874 if (SWIG_arg_fail(1)) SWIG_fail;
24875 {
24876 arg2 = wxString_in_helper(obj1);
24877 if (arg2 == NULL) SWIG_fail;
24878 temp2 = true;
24879 }
24880 {
24881 PyThreadState* __tstate = wxPyBeginAllowThreads();
24882 (arg1)->SetLabel((wxString const &)*arg2);
24883
24884 wxPyEndAllowThreads(__tstate);
24885 if (PyErr_Occurred()) SWIG_fail;
24886 }
24887 Py_INCREF(Py_None); resultobj = Py_None;
24888 {
24889 if (temp2)
24890 delete arg2;
24891 }
24892 return resultobj;
24893 fail:
24894 {
24895 if (temp2)
24896 delete arg2;
24897 }
24898 return NULL;
24899 }
24900
24901
24902 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24903 PyObject *resultobj;
24904 wxWindow *arg1 = (wxWindow *) 0 ;
24905 wxString result;
24906 PyObject * obj0 = 0 ;
24907 char *kwnames[] = {
24908 (char *) "self", NULL
24909 };
24910
24911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24913 if (SWIG_arg_fail(1)) SWIG_fail;
24914 {
24915 PyThreadState* __tstate = wxPyBeginAllowThreads();
24916 result = ((wxWindow const *)arg1)->GetLabel();
24917
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 {
24922 #if wxUSE_UNICODE
24923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24924 #else
24925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24926 #endif
24927 }
24928 return resultobj;
24929 fail:
24930 return NULL;
24931 }
24932
24933
24934 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24935 PyObject *resultobj;
24936 wxWindow *arg1 = (wxWindow *) 0 ;
24937 wxString *arg2 = 0 ;
24938 bool temp2 = false ;
24939 PyObject * obj0 = 0 ;
24940 PyObject * obj1 = 0 ;
24941 char *kwnames[] = {
24942 (char *) "self",(char *) "name", NULL
24943 };
24944
24945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24947 if (SWIG_arg_fail(1)) SWIG_fail;
24948 {
24949 arg2 = wxString_in_helper(obj1);
24950 if (arg2 == NULL) SWIG_fail;
24951 temp2 = true;
24952 }
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 (arg1)->SetName((wxString const &)*arg2);
24956
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 Py_INCREF(Py_None); resultobj = Py_None;
24961 {
24962 if (temp2)
24963 delete arg2;
24964 }
24965 return resultobj;
24966 fail:
24967 {
24968 if (temp2)
24969 delete arg2;
24970 }
24971 return NULL;
24972 }
24973
24974
24975 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24976 PyObject *resultobj;
24977 wxWindow *arg1 = (wxWindow *) 0 ;
24978 wxString result;
24979 PyObject * obj0 = 0 ;
24980 char *kwnames[] = {
24981 (char *) "self", NULL
24982 };
24983
24984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24986 if (SWIG_arg_fail(1)) SWIG_fail;
24987 {
24988 PyThreadState* __tstate = wxPyBeginAllowThreads();
24989 result = ((wxWindow const *)arg1)->GetName();
24990
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 {
24995 #if wxUSE_UNICODE
24996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24997 #else
24998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24999 #endif
25000 }
25001 return resultobj;
25002 fail:
25003 return NULL;
25004 }
25005
25006
25007 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25008 PyObject *resultobj;
25009 wxWindow *arg1 = (wxWindow *) 0 ;
25010 wxWindowVariant arg2 ;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 char *kwnames[] = {
25014 (char *) "self",(char *) "variant", NULL
25015 };
25016
25017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25019 if (SWIG_arg_fail(1)) SWIG_fail;
25020 {
25021 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25022 if (SWIG_arg_fail(2)) SWIG_fail;
25023 }
25024 {
25025 PyThreadState* __tstate = wxPyBeginAllowThreads();
25026 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25027
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 Py_INCREF(Py_None); resultobj = Py_None;
25032 return resultobj;
25033 fail:
25034 return NULL;
25035 }
25036
25037
25038 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj;
25040 wxWindow *arg1 = (wxWindow *) 0 ;
25041 wxWindowVariant result;
25042 PyObject * obj0 = 0 ;
25043 char *kwnames[] = {
25044 (char *) "self", NULL
25045 };
25046
25047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25049 if (SWIG_arg_fail(1)) SWIG_fail;
25050 {
25051 PyThreadState* __tstate = wxPyBeginAllowThreads();
25052 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25053
25054 wxPyEndAllowThreads(__tstate);
25055 if (PyErr_Occurred()) SWIG_fail;
25056 }
25057 resultobj = SWIG_From_int((result));
25058 return resultobj;
25059 fail:
25060 return NULL;
25061 }
25062
25063
25064 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25065 PyObject *resultobj;
25066 wxWindow *arg1 = (wxWindow *) 0 ;
25067 int arg2 ;
25068 PyObject * obj0 = 0 ;
25069 PyObject * obj1 = 0 ;
25070 char *kwnames[] = {
25071 (char *) "self",(char *) "winid", NULL
25072 };
25073
25074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25076 if (SWIG_arg_fail(1)) SWIG_fail;
25077 {
25078 arg2 = (int)(SWIG_As_int(obj1));
25079 if (SWIG_arg_fail(2)) SWIG_fail;
25080 }
25081 {
25082 PyThreadState* __tstate = wxPyBeginAllowThreads();
25083 (arg1)->SetId(arg2);
25084
25085 wxPyEndAllowThreads(__tstate);
25086 if (PyErr_Occurred()) SWIG_fail;
25087 }
25088 Py_INCREF(Py_None); resultobj = Py_None;
25089 return resultobj;
25090 fail:
25091 return NULL;
25092 }
25093
25094
25095 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25096 PyObject *resultobj;
25097 wxWindow *arg1 = (wxWindow *) 0 ;
25098 int result;
25099 PyObject * obj0 = 0 ;
25100 char *kwnames[] = {
25101 (char *) "self", NULL
25102 };
25103
25104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25106 if (SWIG_arg_fail(1)) SWIG_fail;
25107 {
25108 PyThreadState* __tstate = wxPyBeginAllowThreads();
25109 result = (int)((wxWindow const *)arg1)->GetId();
25110
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 {
25115 resultobj = SWIG_From_int((int)(result));
25116 }
25117 return resultobj;
25118 fail:
25119 return NULL;
25120 }
25121
25122
25123 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25124 PyObject *resultobj;
25125 int result;
25126 char *kwnames[] = {
25127 NULL
25128 };
25129
25130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (int)wxWindow::NewControlId();
25134
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 {
25139 resultobj = SWIG_From_int((int)(result));
25140 }
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25148 PyObject *resultobj;
25149 int arg1 ;
25150 int result;
25151 PyObject * obj0 = 0 ;
25152 char *kwnames[] = {
25153 (char *) "winid", NULL
25154 };
25155
25156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25157 {
25158 arg1 = (int)(SWIG_As_int(obj0));
25159 if (SWIG_arg_fail(1)) SWIG_fail;
25160 }
25161 {
25162 PyThreadState* __tstate = wxPyBeginAllowThreads();
25163 result = (int)wxWindow::NextControlId(arg1);
25164
25165 wxPyEndAllowThreads(__tstate);
25166 if (PyErr_Occurred()) SWIG_fail;
25167 }
25168 {
25169 resultobj = SWIG_From_int((int)(result));
25170 }
25171 return resultobj;
25172 fail:
25173 return NULL;
25174 }
25175
25176
25177 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25178 PyObject *resultobj;
25179 int arg1 ;
25180 int result;
25181 PyObject * obj0 = 0 ;
25182 char *kwnames[] = {
25183 (char *) "winid", NULL
25184 };
25185
25186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25187 {
25188 arg1 = (int)(SWIG_As_int(obj0));
25189 if (SWIG_arg_fail(1)) SWIG_fail;
25190 }
25191 {
25192 PyThreadState* __tstate = wxPyBeginAllowThreads();
25193 result = (int)wxWindow::PrevControlId(arg1);
25194
25195 wxPyEndAllowThreads(__tstate);
25196 if (PyErr_Occurred()) SWIG_fail;
25197 }
25198 {
25199 resultobj = SWIG_From_int((int)(result));
25200 }
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj;
25209 wxWindow *arg1 = (wxWindow *) 0 ;
25210 wxSize *arg2 = 0 ;
25211 wxSize temp2 ;
25212 PyObject * obj0 = 0 ;
25213 PyObject * obj1 = 0 ;
25214 char *kwnames[] = {
25215 (char *) "self",(char *) "size", NULL
25216 };
25217
25218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25220 if (SWIG_arg_fail(1)) SWIG_fail;
25221 {
25222 arg2 = &temp2;
25223 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25224 }
25225 {
25226 PyThreadState* __tstate = wxPyBeginAllowThreads();
25227 (arg1)->SetSize((wxSize const &)*arg2);
25228
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 Py_INCREF(Py_None); resultobj = Py_None;
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj;
25241 wxWindow *arg1 = (wxWindow *) 0 ;
25242 int arg2 ;
25243 int arg3 ;
25244 int arg4 ;
25245 int arg5 ;
25246 int arg6 = (int) wxSIZE_AUTO ;
25247 PyObject * obj0 = 0 ;
25248 PyObject * obj1 = 0 ;
25249 PyObject * obj2 = 0 ;
25250 PyObject * obj3 = 0 ;
25251 PyObject * obj4 = 0 ;
25252 PyObject * obj5 = 0 ;
25253 char *kwnames[] = {
25254 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25255 };
25256
25257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25259 if (SWIG_arg_fail(1)) SWIG_fail;
25260 {
25261 arg2 = (int)(SWIG_As_int(obj1));
25262 if (SWIG_arg_fail(2)) SWIG_fail;
25263 }
25264 {
25265 arg3 = (int)(SWIG_As_int(obj2));
25266 if (SWIG_arg_fail(3)) SWIG_fail;
25267 }
25268 {
25269 arg4 = (int)(SWIG_As_int(obj3));
25270 if (SWIG_arg_fail(4)) SWIG_fail;
25271 }
25272 {
25273 arg5 = (int)(SWIG_As_int(obj4));
25274 if (SWIG_arg_fail(5)) SWIG_fail;
25275 }
25276 if (obj5) {
25277 {
25278 arg6 = (int)(SWIG_As_int(obj5));
25279 if (SWIG_arg_fail(6)) SWIG_fail;
25280 }
25281 }
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25285
25286 wxPyEndAllowThreads(__tstate);
25287 if (PyErr_Occurred()) SWIG_fail;
25288 }
25289 Py_INCREF(Py_None); resultobj = Py_None;
25290 return resultobj;
25291 fail:
25292 return NULL;
25293 }
25294
25295
25296 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25297 PyObject *resultobj;
25298 wxWindow *arg1 = (wxWindow *) 0 ;
25299 wxRect *arg2 = 0 ;
25300 int arg3 = (int) wxSIZE_AUTO ;
25301 wxRect temp2 ;
25302 PyObject * obj0 = 0 ;
25303 PyObject * obj1 = 0 ;
25304 PyObject * obj2 = 0 ;
25305 char *kwnames[] = {
25306 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25307 };
25308
25309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25311 if (SWIG_arg_fail(1)) SWIG_fail;
25312 {
25313 arg2 = &temp2;
25314 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25315 }
25316 if (obj2) {
25317 {
25318 arg3 = (int)(SWIG_As_int(obj2));
25319 if (SWIG_arg_fail(3)) SWIG_fail;
25320 }
25321 }
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25325
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 Py_INCREF(Py_None); resultobj = Py_None;
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25337 PyObject *resultobj;
25338 wxWindow *arg1 = (wxWindow *) 0 ;
25339 int arg2 ;
25340 int arg3 ;
25341 PyObject * obj0 = 0 ;
25342 PyObject * obj1 = 0 ;
25343 PyObject * obj2 = 0 ;
25344 char *kwnames[] = {
25345 (char *) "self",(char *) "width",(char *) "height", NULL
25346 };
25347
25348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25350 if (SWIG_arg_fail(1)) SWIG_fail;
25351 {
25352 arg2 = (int)(SWIG_As_int(obj1));
25353 if (SWIG_arg_fail(2)) SWIG_fail;
25354 }
25355 {
25356 arg3 = (int)(SWIG_As_int(obj2));
25357 if (SWIG_arg_fail(3)) SWIG_fail;
25358 }
25359 {
25360 PyThreadState* __tstate = wxPyBeginAllowThreads();
25361 (arg1)->SetSize(arg2,arg3);
25362
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 Py_INCREF(Py_None); resultobj = Py_None;
25367 return resultobj;
25368 fail:
25369 return NULL;
25370 }
25371
25372
25373 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25374 PyObject *resultobj;
25375 wxWindow *arg1 = (wxWindow *) 0 ;
25376 wxPoint *arg2 = 0 ;
25377 int arg3 = (int) wxSIZE_USE_EXISTING ;
25378 wxPoint temp2 ;
25379 PyObject * obj0 = 0 ;
25380 PyObject * obj1 = 0 ;
25381 PyObject * obj2 = 0 ;
25382 char *kwnames[] = {
25383 (char *) "self",(char *) "pt",(char *) "flags", NULL
25384 };
25385
25386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25388 if (SWIG_arg_fail(1)) SWIG_fail;
25389 {
25390 arg2 = &temp2;
25391 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25392 }
25393 if (obj2) {
25394 {
25395 arg3 = (int)(SWIG_As_int(obj2));
25396 if (SWIG_arg_fail(3)) SWIG_fail;
25397 }
25398 }
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 (arg1)->Move((wxPoint const &)*arg2,arg3);
25402
25403 wxPyEndAllowThreads(__tstate);
25404 if (PyErr_Occurred()) SWIG_fail;
25405 }
25406 Py_INCREF(Py_None); resultobj = Py_None;
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj;
25415 wxWindow *arg1 = (wxWindow *) 0 ;
25416 int arg2 ;
25417 int arg3 ;
25418 int arg4 = (int) wxSIZE_USE_EXISTING ;
25419 PyObject * obj0 = 0 ;
25420 PyObject * obj1 = 0 ;
25421 PyObject * obj2 = 0 ;
25422 PyObject * obj3 = 0 ;
25423 char *kwnames[] = {
25424 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25425 };
25426
25427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25429 if (SWIG_arg_fail(1)) SWIG_fail;
25430 {
25431 arg2 = (int)(SWIG_As_int(obj1));
25432 if (SWIG_arg_fail(2)) SWIG_fail;
25433 }
25434 {
25435 arg3 = (int)(SWIG_As_int(obj2));
25436 if (SWIG_arg_fail(3)) SWIG_fail;
25437 }
25438 if (obj3) {
25439 {
25440 arg4 = (int)(SWIG_As_int(obj3));
25441 if (SWIG_arg_fail(4)) SWIG_fail;
25442 }
25443 }
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 (arg1)->Move(arg2,arg3,arg4);
25447
25448 wxPyEndAllowThreads(__tstate);
25449 if (PyErr_Occurred()) SWIG_fail;
25450 }
25451 Py_INCREF(Py_None); resultobj = Py_None;
25452 return resultobj;
25453 fail:
25454 return NULL;
25455 }
25456
25457
25458 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25459 PyObject *resultobj;
25460 wxWindow *arg1 = (wxWindow *) 0 ;
25461 wxSize const &arg2_defvalue = wxDefaultSize ;
25462 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25463 wxSize temp2 ;
25464 PyObject * obj0 = 0 ;
25465 PyObject * obj1 = 0 ;
25466 char *kwnames[] = {
25467 (char *) "self",(char *) "size", NULL
25468 };
25469
25470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25472 if (SWIG_arg_fail(1)) SWIG_fail;
25473 if (obj1) {
25474 {
25475 arg2 = &temp2;
25476 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25477 }
25478 }
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25482
25483 wxPyEndAllowThreads(__tstate);
25484 if (PyErr_Occurred()) SWIG_fail;
25485 }
25486 Py_INCREF(Py_None); resultobj = Py_None;
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25494 PyObject *resultobj;
25495 wxWindow *arg1 = (wxWindow *) 0 ;
25496 PyObject * obj0 = 0 ;
25497 char *kwnames[] = {
25498 (char *) "self", NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25506 (arg1)->Raise();
25507
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 Py_INCREF(Py_None); resultobj = Py_None;
25512 return resultobj;
25513 fail:
25514 return NULL;
25515 }
25516
25517
25518 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25519 PyObject *resultobj;
25520 wxWindow *arg1 = (wxWindow *) 0 ;
25521 PyObject * obj0 = 0 ;
25522 char *kwnames[] = {
25523 (char *) "self", NULL
25524 };
25525
25526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25528 if (SWIG_arg_fail(1)) SWIG_fail;
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 (arg1)->Lower();
25532
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 Py_INCREF(Py_None); resultobj = Py_None;
25537 return resultobj;
25538 fail:
25539 return NULL;
25540 }
25541
25542
25543 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25544 PyObject *resultobj;
25545 wxWindow *arg1 = (wxWindow *) 0 ;
25546 wxSize *arg2 = 0 ;
25547 wxSize temp2 ;
25548 PyObject * obj0 = 0 ;
25549 PyObject * obj1 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self",(char *) "size", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 {
25558 arg2 = &temp2;
25559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25560 }
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 (arg1)->SetClientSize((wxSize const &)*arg2);
25564
25565 wxPyEndAllowThreads(__tstate);
25566 if (PyErr_Occurred()) SWIG_fail;
25567 }
25568 Py_INCREF(Py_None); resultobj = Py_None;
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25576 PyObject *resultobj;
25577 wxWindow *arg1 = (wxWindow *) 0 ;
25578 int arg2 ;
25579 int arg3 ;
25580 PyObject * obj0 = 0 ;
25581 PyObject * obj1 = 0 ;
25582 PyObject * obj2 = 0 ;
25583 char *kwnames[] = {
25584 (char *) "self",(char *) "width",(char *) "height", NULL
25585 };
25586
25587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25589 if (SWIG_arg_fail(1)) SWIG_fail;
25590 {
25591 arg2 = (int)(SWIG_As_int(obj1));
25592 if (SWIG_arg_fail(2)) SWIG_fail;
25593 }
25594 {
25595 arg3 = (int)(SWIG_As_int(obj2));
25596 if (SWIG_arg_fail(3)) SWIG_fail;
25597 }
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 (arg1)->SetClientSize(arg2,arg3);
25601
25602 wxPyEndAllowThreads(__tstate);
25603 if (PyErr_Occurred()) SWIG_fail;
25604 }
25605 Py_INCREF(Py_None); resultobj = Py_None;
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj;
25614 wxWindow *arg1 = (wxWindow *) 0 ;
25615 wxRect *arg2 = 0 ;
25616 wxRect temp2 ;
25617 PyObject * obj0 = 0 ;
25618 PyObject * obj1 = 0 ;
25619 char *kwnames[] = {
25620 (char *) "self",(char *) "rect", NULL
25621 };
25622
25623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25625 if (SWIG_arg_fail(1)) SWIG_fail;
25626 {
25627 arg2 = &temp2;
25628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25629 }
25630 {
25631 PyThreadState* __tstate = wxPyBeginAllowThreads();
25632 (arg1)->SetClientSize((wxRect const &)*arg2);
25633
25634 wxPyEndAllowThreads(__tstate);
25635 if (PyErr_Occurred()) SWIG_fail;
25636 }
25637 Py_INCREF(Py_None); resultobj = Py_None;
25638 return resultobj;
25639 fail:
25640 return NULL;
25641 }
25642
25643
25644 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25645 PyObject *resultobj;
25646 wxWindow *arg1 = (wxWindow *) 0 ;
25647 wxPoint result;
25648 PyObject * obj0 = 0 ;
25649 char *kwnames[] = {
25650 (char *) "self", NULL
25651 };
25652
25653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25655 if (SWIG_arg_fail(1)) SWIG_fail;
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 result = (arg1)->GetPosition();
25659
25660 wxPyEndAllowThreads(__tstate);
25661 if (PyErr_Occurred()) SWIG_fail;
25662 }
25663 {
25664 wxPoint * resultptr;
25665 resultptr = new wxPoint((wxPoint &)(result));
25666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25667 }
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25675 PyObject *resultobj;
25676 wxWindow *arg1 = (wxWindow *) 0 ;
25677 int *arg2 = (int *) 0 ;
25678 int *arg3 = (int *) 0 ;
25679 int temp2 ;
25680 int res2 = 0 ;
25681 int temp3 ;
25682 int res3 = 0 ;
25683 PyObject * obj0 = 0 ;
25684 char *kwnames[] = {
25685 (char *) "self", NULL
25686 };
25687
25688 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25689 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25692 if (SWIG_arg_fail(1)) SWIG_fail;
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 (arg1)->GetPosition(arg2,arg3);
25696
25697 wxPyEndAllowThreads(__tstate);
25698 if (PyErr_Occurred()) SWIG_fail;
25699 }
25700 Py_INCREF(Py_None); resultobj = Py_None;
25701 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25702 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25703 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25704 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25705 return resultobj;
25706 fail:
25707 return NULL;
25708 }
25709
25710
25711 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25712 PyObject *resultobj;
25713 wxWindow *arg1 = (wxWindow *) 0 ;
25714 wxSize result;
25715 PyObject * obj0 = 0 ;
25716 char *kwnames[] = {
25717 (char *) "self", NULL
25718 };
25719
25720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25722 if (SWIG_arg_fail(1)) SWIG_fail;
25723 {
25724 PyThreadState* __tstate = wxPyBeginAllowThreads();
25725 result = ((wxWindow const *)arg1)->GetSize();
25726
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 {
25731 wxSize * resultptr;
25732 resultptr = new wxSize((wxSize &)(result));
25733 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25734 }
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj;
25743 wxWindow *arg1 = (wxWindow *) 0 ;
25744 int *arg2 = (int *) 0 ;
25745 int *arg3 = (int *) 0 ;
25746 int temp2 ;
25747 int res2 = 0 ;
25748 int temp3 ;
25749 int res3 = 0 ;
25750 PyObject * obj0 = 0 ;
25751 char *kwnames[] = {
25752 (char *) "self", NULL
25753 };
25754
25755 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25756 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25759 if (SWIG_arg_fail(1)) SWIG_fail;
25760 {
25761 PyThreadState* __tstate = wxPyBeginAllowThreads();
25762 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25763
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 Py_INCREF(Py_None); resultobj = Py_None;
25768 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25769 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25770 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25771 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25772 return resultobj;
25773 fail:
25774 return NULL;
25775 }
25776
25777
25778 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25779 PyObject *resultobj;
25780 wxWindow *arg1 = (wxWindow *) 0 ;
25781 wxRect result;
25782 PyObject * obj0 = 0 ;
25783 char *kwnames[] = {
25784 (char *) "self", NULL
25785 };
25786
25787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25789 if (SWIG_arg_fail(1)) SWIG_fail;
25790 {
25791 PyThreadState* __tstate = wxPyBeginAllowThreads();
25792 result = ((wxWindow const *)arg1)->GetRect();
25793
25794 wxPyEndAllowThreads(__tstate);
25795 if (PyErr_Occurred()) SWIG_fail;
25796 }
25797 {
25798 wxRect * resultptr;
25799 resultptr = new wxRect((wxRect &)(result));
25800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25801 }
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25809 PyObject *resultobj;
25810 wxWindow *arg1 = (wxWindow *) 0 ;
25811 wxSize result;
25812 PyObject * obj0 = 0 ;
25813 char *kwnames[] = {
25814 (char *) "self", NULL
25815 };
25816
25817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25819 if (SWIG_arg_fail(1)) SWIG_fail;
25820 {
25821 PyThreadState* __tstate = wxPyBeginAllowThreads();
25822 result = ((wxWindow const *)arg1)->GetClientSize();
25823
25824 wxPyEndAllowThreads(__tstate);
25825 if (PyErr_Occurred()) SWIG_fail;
25826 }
25827 {
25828 wxSize * resultptr;
25829 resultptr = new wxSize((wxSize &)(result));
25830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25831 }
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25839 PyObject *resultobj;
25840 wxWindow *arg1 = (wxWindow *) 0 ;
25841 int *arg2 = (int *) 0 ;
25842 int *arg3 = (int *) 0 ;
25843 int temp2 ;
25844 int res2 = 0 ;
25845 int temp3 ;
25846 int res3 = 0 ;
25847 PyObject * obj0 = 0 ;
25848 char *kwnames[] = {
25849 (char *) "self", NULL
25850 };
25851
25852 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25853 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25856 if (SWIG_arg_fail(1)) SWIG_fail;
25857 {
25858 PyThreadState* __tstate = wxPyBeginAllowThreads();
25859 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25860
25861 wxPyEndAllowThreads(__tstate);
25862 if (PyErr_Occurred()) SWIG_fail;
25863 }
25864 Py_INCREF(Py_None); resultobj = Py_None;
25865 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25866 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25867 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25868 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25876 PyObject *resultobj;
25877 wxWindow *arg1 = (wxWindow *) 0 ;
25878 wxPoint result;
25879 PyObject * obj0 = 0 ;
25880 char *kwnames[] = {
25881 (char *) "self", NULL
25882 };
25883
25884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25886 if (SWIG_arg_fail(1)) SWIG_fail;
25887 {
25888 PyThreadState* __tstate = wxPyBeginAllowThreads();
25889 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25890
25891 wxPyEndAllowThreads(__tstate);
25892 if (PyErr_Occurred()) SWIG_fail;
25893 }
25894 {
25895 wxPoint * resultptr;
25896 resultptr = new wxPoint((wxPoint &)(result));
25897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25898 }
25899 return resultobj;
25900 fail:
25901 return NULL;
25902 }
25903
25904
25905 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj;
25907 wxWindow *arg1 = (wxWindow *) 0 ;
25908 wxRect result;
25909 PyObject * obj0 = 0 ;
25910 char *kwnames[] = {
25911 (char *) "self", NULL
25912 };
25913
25914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25916 if (SWIG_arg_fail(1)) SWIG_fail;
25917 {
25918 PyThreadState* __tstate = wxPyBeginAllowThreads();
25919 result = ((wxWindow const *)arg1)->GetClientRect();
25920
25921 wxPyEndAllowThreads(__tstate);
25922 if (PyErr_Occurred()) SWIG_fail;
25923 }
25924 {
25925 wxRect * resultptr;
25926 resultptr = new wxRect((wxRect &)(result));
25927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25928 }
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25936 PyObject *resultobj;
25937 wxWindow *arg1 = (wxWindow *) 0 ;
25938 wxSize result;
25939 PyObject * obj0 = 0 ;
25940 char *kwnames[] = {
25941 (char *) "self", NULL
25942 };
25943
25944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25946 if (SWIG_arg_fail(1)) SWIG_fail;
25947 {
25948 PyThreadState* __tstate = wxPyBeginAllowThreads();
25949 result = ((wxWindow const *)arg1)->GetBestSize();
25950
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 {
25955 wxSize * resultptr;
25956 resultptr = new wxSize((wxSize &)(result));
25957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25958 }
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25966 PyObject *resultobj;
25967 wxWindow *arg1 = (wxWindow *) 0 ;
25968 int *arg2 = (int *) 0 ;
25969 int *arg3 = (int *) 0 ;
25970 int temp2 ;
25971 int res2 = 0 ;
25972 int temp3 ;
25973 int res3 = 0 ;
25974 PyObject * obj0 = 0 ;
25975 char *kwnames[] = {
25976 (char *) "self", NULL
25977 };
25978
25979 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25980 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25983 if (SWIG_arg_fail(1)) SWIG_fail;
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25987
25988 wxPyEndAllowThreads(__tstate);
25989 if (PyErr_Occurred()) SWIG_fail;
25990 }
25991 Py_INCREF(Py_None); resultobj = Py_None;
25992 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25993 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25994 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25995 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25996 return resultobj;
25997 fail:
25998 return NULL;
25999 }
26000
26001
26002 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj;
26004 wxWindow *arg1 = (wxWindow *) 0 ;
26005 PyObject * obj0 = 0 ;
26006 char *kwnames[] = {
26007 (char *) "self", NULL
26008 };
26009
26010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26012 if (SWIG_arg_fail(1)) SWIG_fail;
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 (arg1)->InvalidateBestSize();
26016
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 Py_INCREF(Py_None); resultobj = Py_None;
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj;
26029 wxWindow *arg1 = (wxWindow *) 0 ;
26030 wxSize result;
26031 PyObject * obj0 = 0 ;
26032 char *kwnames[] = {
26033 (char *) "self", NULL
26034 };
26035
26036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26038 if (SWIG_arg_fail(1)) SWIG_fail;
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26042
26043 wxPyEndAllowThreads(__tstate);
26044 if (PyErr_Occurred()) SWIG_fail;
26045 }
26046 {
26047 wxSize * resultptr;
26048 resultptr = new wxSize((wxSize &)(result));
26049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26050 }
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26058 PyObject *resultobj;
26059 wxWindow *arg1 = (wxWindow *) 0 ;
26060 wxSize result;
26061 PyObject * obj0 = 0 ;
26062 char *kwnames[] = {
26063 (char *) "self", NULL
26064 };
26065
26066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26068 if (SWIG_arg_fail(1)) SWIG_fail;
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26072
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 {
26077 wxSize * resultptr;
26078 resultptr = new wxSize((wxSize &)(result));
26079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26080 }
26081 return resultobj;
26082 fail:
26083 return NULL;
26084 }
26085
26086
26087 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26088 PyObject *resultobj;
26089 wxWindow *arg1 = (wxWindow *) 0 ;
26090 int arg2 = (int) wxBOTH ;
26091 PyObject * obj0 = 0 ;
26092 PyObject * obj1 = 0 ;
26093 char *kwnames[] = {
26094 (char *) "self",(char *) "direction", NULL
26095 };
26096
26097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26099 if (SWIG_arg_fail(1)) SWIG_fail;
26100 if (obj1) {
26101 {
26102 arg2 = (int)(SWIG_As_int(obj1));
26103 if (SWIG_arg_fail(2)) SWIG_fail;
26104 }
26105 }
26106 {
26107 PyThreadState* __tstate = wxPyBeginAllowThreads();
26108 (arg1)->Center(arg2);
26109
26110 wxPyEndAllowThreads(__tstate);
26111 if (PyErr_Occurred()) SWIG_fail;
26112 }
26113 Py_INCREF(Py_None); resultobj = Py_None;
26114 return resultobj;
26115 fail:
26116 return NULL;
26117 }
26118
26119
26120 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26121 PyObject *resultobj;
26122 wxWindow *arg1 = (wxWindow *) 0 ;
26123 int arg2 = (int) wxBOTH ;
26124 PyObject * obj0 = 0 ;
26125 PyObject * obj1 = 0 ;
26126 char *kwnames[] = {
26127 (char *) "self",(char *) "dir", NULL
26128 };
26129
26130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26132 if (SWIG_arg_fail(1)) SWIG_fail;
26133 if (obj1) {
26134 {
26135 arg2 = (int)(SWIG_As_int(obj1));
26136 if (SWIG_arg_fail(2)) SWIG_fail;
26137 }
26138 }
26139 {
26140 PyThreadState* __tstate = wxPyBeginAllowThreads();
26141 (arg1)->CenterOnScreen(arg2);
26142
26143 wxPyEndAllowThreads(__tstate);
26144 if (PyErr_Occurred()) SWIG_fail;
26145 }
26146 Py_INCREF(Py_None); resultobj = Py_None;
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj;
26155 wxWindow *arg1 = (wxWindow *) 0 ;
26156 int arg2 = (int) wxBOTH ;
26157 PyObject * obj0 = 0 ;
26158 PyObject * obj1 = 0 ;
26159 char *kwnames[] = {
26160 (char *) "self",(char *) "dir", NULL
26161 };
26162
26163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26165 if (SWIG_arg_fail(1)) SWIG_fail;
26166 if (obj1) {
26167 {
26168 arg2 = (int)(SWIG_As_int(obj1));
26169 if (SWIG_arg_fail(2)) SWIG_fail;
26170 }
26171 }
26172 {
26173 PyThreadState* __tstate = wxPyBeginAllowThreads();
26174 (arg1)->CenterOnParent(arg2);
26175
26176 wxPyEndAllowThreads(__tstate);
26177 if (PyErr_Occurred()) SWIG_fail;
26178 }
26179 Py_INCREF(Py_None); resultobj = Py_None;
26180 return resultobj;
26181 fail:
26182 return NULL;
26183 }
26184
26185
26186 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26187 PyObject *resultobj;
26188 wxWindow *arg1 = (wxWindow *) 0 ;
26189 PyObject * obj0 = 0 ;
26190 char *kwnames[] = {
26191 (char *) "self", NULL
26192 };
26193
26194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26196 if (SWIG_arg_fail(1)) SWIG_fail;
26197 {
26198 PyThreadState* __tstate = wxPyBeginAllowThreads();
26199 (arg1)->Fit();
26200
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 Py_INCREF(Py_None); resultobj = Py_None;
26205 return resultobj;
26206 fail:
26207 return NULL;
26208 }
26209
26210
26211 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26212 PyObject *resultobj;
26213 wxWindow *arg1 = (wxWindow *) 0 ;
26214 PyObject * obj0 = 0 ;
26215 char *kwnames[] = {
26216 (char *) "self", NULL
26217 };
26218
26219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26221 if (SWIG_arg_fail(1)) SWIG_fail;
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 (arg1)->FitInside();
26225
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 Py_INCREF(Py_None); resultobj = Py_None;
26230 return resultobj;
26231 fail:
26232 return NULL;
26233 }
26234
26235
26236 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26237 PyObject *resultobj;
26238 wxWindow *arg1 = (wxWindow *) 0 ;
26239 int arg2 ;
26240 int arg3 ;
26241 int arg4 = (int) -1 ;
26242 int arg5 = (int) -1 ;
26243 int arg6 = (int) -1 ;
26244 int arg7 = (int) -1 ;
26245 PyObject * obj0 = 0 ;
26246 PyObject * obj1 = 0 ;
26247 PyObject * obj2 = 0 ;
26248 PyObject * obj3 = 0 ;
26249 PyObject * obj4 = 0 ;
26250 PyObject * obj5 = 0 ;
26251 PyObject * obj6 = 0 ;
26252 char *kwnames[] = {
26253 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26254 };
26255
26256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26258 if (SWIG_arg_fail(1)) SWIG_fail;
26259 {
26260 arg2 = (int)(SWIG_As_int(obj1));
26261 if (SWIG_arg_fail(2)) SWIG_fail;
26262 }
26263 {
26264 arg3 = (int)(SWIG_As_int(obj2));
26265 if (SWIG_arg_fail(3)) SWIG_fail;
26266 }
26267 if (obj3) {
26268 {
26269 arg4 = (int)(SWIG_As_int(obj3));
26270 if (SWIG_arg_fail(4)) SWIG_fail;
26271 }
26272 }
26273 if (obj4) {
26274 {
26275 arg5 = (int)(SWIG_As_int(obj4));
26276 if (SWIG_arg_fail(5)) SWIG_fail;
26277 }
26278 }
26279 if (obj5) {
26280 {
26281 arg6 = (int)(SWIG_As_int(obj5));
26282 if (SWIG_arg_fail(6)) SWIG_fail;
26283 }
26284 }
26285 if (obj6) {
26286 {
26287 arg7 = (int)(SWIG_As_int(obj6));
26288 if (SWIG_arg_fail(7)) SWIG_fail;
26289 }
26290 }
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26294
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 Py_INCREF(Py_None); resultobj = Py_None;
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26306 PyObject *resultobj;
26307 wxWindow *arg1 = (wxWindow *) 0 ;
26308 wxSize *arg2 = 0 ;
26309 wxSize const &arg3_defvalue = wxDefaultSize ;
26310 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26311 wxSize const &arg4_defvalue = wxDefaultSize ;
26312 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26313 wxSize temp2 ;
26314 wxSize temp3 ;
26315 wxSize temp4 ;
26316 PyObject * obj0 = 0 ;
26317 PyObject * obj1 = 0 ;
26318 PyObject * obj2 = 0 ;
26319 PyObject * obj3 = 0 ;
26320 char *kwnames[] = {
26321 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26322 };
26323
26324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(1)) SWIG_fail;
26327 {
26328 arg2 = &temp2;
26329 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26330 }
26331 if (obj2) {
26332 {
26333 arg3 = &temp3;
26334 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26335 }
26336 }
26337 if (obj3) {
26338 {
26339 arg4 = &temp4;
26340 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26341 }
26342 }
26343 {
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26346
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 Py_INCREF(Py_None); resultobj = Py_None;
26351 return resultobj;
26352 fail:
26353 return NULL;
26354 }
26355
26356
26357 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26358 PyObject *resultobj;
26359 wxWindow *arg1 = (wxWindow *) 0 ;
26360 int arg2 ;
26361 int arg3 ;
26362 int arg4 = (int) -1 ;
26363 int arg5 = (int) -1 ;
26364 PyObject * obj0 = 0 ;
26365 PyObject * obj1 = 0 ;
26366 PyObject * obj2 = 0 ;
26367 PyObject * obj3 = 0 ;
26368 PyObject * obj4 = 0 ;
26369 char *kwnames[] = {
26370 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26371 };
26372
26373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26375 if (SWIG_arg_fail(1)) SWIG_fail;
26376 {
26377 arg2 = (int)(SWIG_As_int(obj1));
26378 if (SWIG_arg_fail(2)) SWIG_fail;
26379 }
26380 {
26381 arg3 = (int)(SWIG_As_int(obj2));
26382 if (SWIG_arg_fail(3)) SWIG_fail;
26383 }
26384 if (obj3) {
26385 {
26386 arg4 = (int)(SWIG_As_int(obj3));
26387 if (SWIG_arg_fail(4)) SWIG_fail;
26388 }
26389 }
26390 if (obj4) {
26391 {
26392 arg5 = (int)(SWIG_As_int(obj4));
26393 if (SWIG_arg_fail(5)) SWIG_fail;
26394 }
26395 }
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26399
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 Py_INCREF(Py_None); resultobj = Py_None;
26404 return resultobj;
26405 fail:
26406 return NULL;
26407 }
26408
26409
26410 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26411 PyObject *resultobj;
26412 wxWindow *arg1 = (wxWindow *) 0 ;
26413 wxSize *arg2 = 0 ;
26414 wxSize const &arg3_defvalue = wxDefaultSize ;
26415 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26416 wxSize temp2 ;
26417 wxSize temp3 ;
26418 PyObject * obj0 = 0 ;
26419 PyObject * obj1 = 0 ;
26420 PyObject * obj2 = 0 ;
26421 char *kwnames[] = {
26422 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26423 };
26424
26425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26427 if (SWIG_arg_fail(1)) SWIG_fail;
26428 {
26429 arg2 = &temp2;
26430 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26431 }
26432 if (obj2) {
26433 {
26434 arg3 = &temp3;
26435 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26436 }
26437 }
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26441
26442 wxPyEndAllowThreads(__tstate);
26443 if (PyErr_Occurred()) SWIG_fail;
26444 }
26445 Py_INCREF(Py_None); resultobj = Py_None;
26446 return resultobj;
26447 fail:
26448 return NULL;
26449 }
26450
26451
26452 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26453 PyObject *resultobj;
26454 wxWindow *arg1 = (wxWindow *) 0 ;
26455 wxSize result;
26456 PyObject * obj0 = 0 ;
26457 char *kwnames[] = {
26458 (char *) "self", NULL
26459 };
26460
26461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26463 if (SWIG_arg_fail(1)) SWIG_fail;
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 result = ((wxWindow const *)arg1)->GetMaxSize();
26467
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 {
26472 wxSize * resultptr;
26473 resultptr = new wxSize((wxSize &)(result));
26474 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26475 }
26476 return resultobj;
26477 fail:
26478 return NULL;
26479 }
26480
26481
26482 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26483 PyObject *resultobj;
26484 wxWindow *arg1 = (wxWindow *) 0 ;
26485 wxSize result;
26486 PyObject * obj0 = 0 ;
26487 char *kwnames[] = {
26488 (char *) "self", NULL
26489 };
26490
26491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26493 if (SWIG_arg_fail(1)) SWIG_fail;
26494 {
26495 PyThreadState* __tstate = wxPyBeginAllowThreads();
26496 result = ((wxWindow const *)arg1)->GetMinSize();
26497
26498 wxPyEndAllowThreads(__tstate);
26499 if (PyErr_Occurred()) SWIG_fail;
26500 }
26501 {
26502 wxSize * resultptr;
26503 resultptr = new wxSize((wxSize &)(result));
26504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26505 }
26506 return resultobj;
26507 fail:
26508 return NULL;
26509 }
26510
26511
26512 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26513 PyObject *resultobj;
26514 wxWindow *arg1 = (wxWindow *) 0 ;
26515 wxSize *arg2 = 0 ;
26516 wxSize temp2 ;
26517 PyObject * obj0 = 0 ;
26518 PyObject * obj1 = 0 ;
26519 char *kwnames[] = {
26520 (char *) "self",(char *) "minSize", NULL
26521 };
26522
26523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26525 if (SWIG_arg_fail(1)) SWIG_fail;
26526 {
26527 arg2 = &temp2;
26528 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26529 }
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 (arg1)->SetMinSize((wxSize const &)*arg2);
26533
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 Py_INCREF(Py_None); resultobj = Py_None;
26538 return resultobj;
26539 fail:
26540 return NULL;
26541 }
26542
26543
26544 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26545 PyObject *resultobj;
26546 wxWindow *arg1 = (wxWindow *) 0 ;
26547 wxSize *arg2 = 0 ;
26548 wxSize temp2 ;
26549 PyObject * obj0 = 0 ;
26550 PyObject * obj1 = 0 ;
26551 char *kwnames[] = {
26552 (char *) "self",(char *) "maxSize", NULL
26553 };
26554
26555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26557 if (SWIG_arg_fail(1)) SWIG_fail;
26558 {
26559 arg2 = &temp2;
26560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26561 }
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 (arg1)->SetMaxSize((wxSize const &)*arg2);
26565
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 Py_INCREF(Py_None); resultobj = Py_None;
26570 return resultobj;
26571 fail:
26572 return NULL;
26573 }
26574
26575
26576 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26577 PyObject *resultobj;
26578 wxWindow *arg1 = (wxWindow *) 0 ;
26579 int result;
26580 PyObject * obj0 = 0 ;
26581 char *kwnames[] = {
26582 (char *) "self", NULL
26583 };
26584
26585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26587 if (SWIG_arg_fail(1)) SWIG_fail;
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26591
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 {
26596 resultobj = SWIG_From_int((int)(result));
26597 }
26598 return resultobj;
26599 fail:
26600 return NULL;
26601 }
26602
26603
26604 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26605 PyObject *resultobj;
26606 wxWindow *arg1 = (wxWindow *) 0 ;
26607 int result;
26608 PyObject * obj0 = 0 ;
26609 char *kwnames[] = {
26610 (char *) "self", NULL
26611 };
26612
26613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26615 if (SWIG_arg_fail(1)) SWIG_fail;
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26619
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = SWIG_From_int((int)(result));
26625 }
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26633 PyObject *resultobj;
26634 wxWindow *arg1 = (wxWindow *) 0 ;
26635 int result;
26636 PyObject * obj0 = 0 ;
26637 char *kwnames[] = {
26638 (char *) "self", NULL
26639 };
26640
26641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26643 if (SWIG_arg_fail(1)) SWIG_fail;
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26647
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 {
26652 resultobj = SWIG_From_int((int)(result));
26653 }
26654 return resultobj;
26655 fail:
26656 return NULL;
26657 }
26658
26659
26660 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj;
26662 wxWindow *arg1 = (wxWindow *) 0 ;
26663 int result;
26664 PyObject * obj0 = 0 ;
26665 char *kwnames[] = {
26666 (char *) "self", NULL
26667 };
26668
26669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26671 if (SWIG_arg_fail(1)) SWIG_fail;
26672 {
26673 PyThreadState* __tstate = wxPyBeginAllowThreads();
26674 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26675
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 {
26680 resultobj = SWIG_From_int((int)(result));
26681 }
26682 return resultobj;
26683 fail:
26684 return NULL;
26685 }
26686
26687
26688 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26689 PyObject *resultobj;
26690 wxWindow *arg1 = (wxWindow *) 0 ;
26691 wxSize *arg2 = 0 ;
26692 wxSize temp2 ;
26693 PyObject * obj0 = 0 ;
26694 PyObject * obj1 = 0 ;
26695 char *kwnames[] = {
26696 (char *) "self",(char *) "size", NULL
26697 };
26698
26699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26701 if (SWIG_arg_fail(1)) SWIG_fail;
26702 {
26703 arg2 = &temp2;
26704 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26705 }
26706 {
26707 PyThreadState* __tstate = wxPyBeginAllowThreads();
26708 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26709
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 Py_INCREF(Py_None); resultobj = Py_None;
26714 return resultobj;
26715 fail:
26716 return NULL;
26717 }
26718
26719
26720 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26721 PyObject *resultobj;
26722 wxWindow *arg1 = (wxWindow *) 0 ;
26723 int arg2 ;
26724 int arg3 ;
26725 PyObject * obj0 = 0 ;
26726 PyObject * obj1 = 0 ;
26727 PyObject * obj2 = 0 ;
26728 char *kwnames[] = {
26729 (char *) "self",(char *) "w",(char *) "h", NULL
26730 };
26731
26732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26734 if (SWIG_arg_fail(1)) SWIG_fail;
26735 {
26736 arg2 = (int)(SWIG_As_int(obj1));
26737 if (SWIG_arg_fail(2)) SWIG_fail;
26738 }
26739 {
26740 arg3 = (int)(SWIG_As_int(obj2));
26741 if (SWIG_arg_fail(3)) SWIG_fail;
26742 }
26743 {
26744 PyThreadState* __tstate = wxPyBeginAllowThreads();
26745 (arg1)->SetVirtualSize(arg2,arg3);
26746
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 Py_INCREF(Py_None); resultobj = Py_None;
26751 return resultobj;
26752 fail:
26753 return NULL;
26754 }
26755
26756
26757 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26758 PyObject *resultobj;
26759 wxWindow *arg1 = (wxWindow *) 0 ;
26760 wxSize result;
26761 PyObject * obj0 = 0 ;
26762 char *kwnames[] = {
26763 (char *) "self", NULL
26764 };
26765
26766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26768 if (SWIG_arg_fail(1)) SWIG_fail;
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = ((wxWindow const *)arg1)->GetVirtualSize();
26772
26773 wxPyEndAllowThreads(__tstate);
26774 if (PyErr_Occurred()) SWIG_fail;
26775 }
26776 {
26777 wxSize * resultptr;
26778 resultptr = new wxSize((wxSize &)(result));
26779 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26780 }
26781 return resultobj;
26782 fail:
26783 return NULL;
26784 }
26785
26786
26787 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26788 PyObject *resultobj;
26789 wxWindow *arg1 = (wxWindow *) 0 ;
26790 int *arg2 = (int *) 0 ;
26791 int *arg3 = (int *) 0 ;
26792 int temp2 ;
26793 int res2 = 0 ;
26794 int temp3 ;
26795 int res3 = 0 ;
26796 PyObject * obj0 = 0 ;
26797 char *kwnames[] = {
26798 (char *) "self", NULL
26799 };
26800
26801 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26802 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26805 if (SWIG_arg_fail(1)) SWIG_fail;
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26809
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 Py_INCREF(Py_None); resultobj = Py_None;
26814 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26815 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26816 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26817 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26818 return resultobj;
26819 fail:
26820 return NULL;
26821 }
26822
26823
26824 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj;
26826 wxWindow *arg1 = (wxWindow *) 0 ;
26827 wxSize result;
26828 PyObject * obj0 = 0 ;
26829 char *kwnames[] = {
26830 (char *) "self", NULL
26831 };
26832
26833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26835 if (SWIG_arg_fail(1)) SWIG_fail;
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26839
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 wxSize * resultptr;
26845 resultptr = new wxSize((wxSize &)(result));
26846 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26847 }
26848 return resultobj;
26849 fail:
26850 return NULL;
26851 }
26852
26853
26854 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj;
26856 wxWindow *arg1 = (wxWindow *) 0 ;
26857 bool arg2 = (bool) true ;
26858 bool result;
26859 PyObject * obj0 = 0 ;
26860 PyObject * obj1 = 0 ;
26861 char *kwnames[] = {
26862 (char *) "self",(char *) "show", NULL
26863 };
26864
26865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26867 if (SWIG_arg_fail(1)) SWIG_fail;
26868 if (obj1) {
26869 {
26870 arg2 = (bool)(SWIG_As_bool(obj1));
26871 if (SWIG_arg_fail(2)) SWIG_fail;
26872 }
26873 }
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 result = (bool)(arg1)->Show(arg2);
26877
26878 wxPyEndAllowThreads(__tstate);
26879 if (PyErr_Occurred()) SWIG_fail;
26880 }
26881 {
26882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26883 }
26884 return resultobj;
26885 fail:
26886 return NULL;
26887 }
26888
26889
26890 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26891 PyObject *resultobj;
26892 wxWindow *arg1 = (wxWindow *) 0 ;
26893 bool result;
26894 PyObject * obj0 = 0 ;
26895 char *kwnames[] = {
26896 (char *) "self", NULL
26897 };
26898
26899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26901 if (SWIG_arg_fail(1)) SWIG_fail;
26902 {
26903 PyThreadState* __tstate = wxPyBeginAllowThreads();
26904 result = (bool)(arg1)->Hide();
26905
26906 wxPyEndAllowThreads(__tstate);
26907 if (PyErr_Occurred()) SWIG_fail;
26908 }
26909 {
26910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26911 }
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26919 PyObject *resultobj;
26920 wxWindow *arg1 = (wxWindow *) 0 ;
26921 bool arg2 = (bool) true ;
26922 bool result;
26923 PyObject * obj0 = 0 ;
26924 PyObject * obj1 = 0 ;
26925 char *kwnames[] = {
26926 (char *) "self",(char *) "enable", NULL
26927 };
26928
26929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26931 if (SWIG_arg_fail(1)) SWIG_fail;
26932 if (obj1) {
26933 {
26934 arg2 = (bool)(SWIG_As_bool(obj1));
26935 if (SWIG_arg_fail(2)) SWIG_fail;
26936 }
26937 }
26938 {
26939 PyThreadState* __tstate = wxPyBeginAllowThreads();
26940 result = (bool)(arg1)->Enable(arg2);
26941
26942 wxPyEndAllowThreads(__tstate);
26943 if (PyErr_Occurred()) SWIG_fail;
26944 }
26945 {
26946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26947 }
26948 return resultobj;
26949 fail:
26950 return NULL;
26951 }
26952
26953
26954 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26955 PyObject *resultobj;
26956 wxWindow *arg1 = (wxWindow *) 0 ;
26957 bool result;
26958 PyObject * obj0 = 0 ;
26959 char *kwnames[] = {
26960 (char *) "self", NULL
26961 };
26962
26963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26965 if (SWIG_arg_fail(1)) SWIG_fail;
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 result = (bool)(arg1)->Disable();
26969
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 {
26974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26975 }
26976 return resultobj;
26977 fail:
26978 return NULL;
26979 }
26980
26981
26982 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26983 PyObject *resultobj;
26984 wxWindow *arg1 = (wxWindow *) 0 ;
26985 bool result;
26986 PyObject * obj0 = 0 ;
26987 char *kwnames[] = {
26988 (char *) "self", NULL
26989 };
26990
26991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26993 if (SWIG_arg_fail(1)) SWIG_fail;
26994 {
26995 PyThreadState* __tstate = wxPyBeginAllowThreads();
26996 result = (bool)((wxWindow const *)arg1)->IsShown();
26997
26998 wxPyEndAllowThreads(__tstate);
26999 if (PyErr_Occurred()) SWIG_fail;
27000 }
27001 {
27002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27003 }
27004 return resultobj;
27005 fail:
27006 return NULL;
27007 }
27008
27009
27010 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27011 PyObject *resultobj;
27012 wxWindow *arg1 = (wxWindow *) 0 ;
27013 bool result;
27014 PyObject * obj0 = 0 ;
27015 char *kwnames[] = {
27016 (char *) "self", NULL
27017 };
27018
27019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27021 if (SWIG_arg_fail(1)) SWIG_fail;
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27025
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 {
27030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27031 }
27032 return resultobj;
27033 fail:
27034 return NULL;
27035 }
27036
27037
27038 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27039 PyObject *resultobj;
27040 wxWindow *arg1 = (wxWindow *) 0 ;
27041 long arg2 ;
27042 PyObject * obj0 = 0 ;
27043 PyObject * obj1 = 0 ;
27044 char *kwnames[] = {
27045 (char *) "self",(char *) "style", NULL
27046 };
27047
27048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27050 if (SWIG_arg_fail(1)) SWIG_fail;
27051 {
27052 arg2 = (long)(SWIG_As_long(obj1));
27053 if (SWIG_arg_fail(2)) SWIG_fail;
27054 }
27055 {
27056 PyThreadState* __tstate = wxPyBeginAllowThreads();
27057 (arg1)->SetWindowStyleFlag(arg2);
27058
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 Py_INCREF(Py_None); resultobj = Py_None;
27063 return resultobj;
27064 fail:
27065 return NULL;
27066 }
27067
27068
27069 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27070 PyObject *resultobj;
27071 wxWindow *arg1 = (wxWindow *) 0 ;
27072 long result;
27073 PyObject * obj0 = 0 ;
27074 char *kwnames[] = {
27075 (char *) "self", NULL
27076 };
27077
27078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27080 if (SWIG_arg_fail(1)) SWIG_fail;
27081 {
27082 PyThreadState* __tstate = wxPyBeginAllowThreads();
27083 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27084
27085 wxPyEndAllowThreads(__tstate);
27086 if (PyErr_Occurred()) SWIG_fail;
27087 }
27088 {
27089 resultobj = SWIG_From_long((long)(result));
27090 }
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj;
27099 wxWindow *arg1 = (wxWindow *) 0 ;
27100 int arg2 ;
27101 bool result;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 char *kwnames[] = {
27105 (char *) "self",(char *) "flag", NULL
27106 };
27107
27108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27110 if (SWIG_arg_fail(1)) SWIG_fail;
27111 {
27112 arg2 = (int)(SWIG_As_int(obj1));
27113 if (SWIG_arg_fail(2)) SWIG_fail;
27114 }
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27118
27119 wxPyEndAllowThreads(__tstate);
27120 if (PyErr_Occurred()) SWIG_fail;
27121 }
27122 {
27123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27124 }
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27132 PyObject *resultobj;
27133 wxWindow *arg1 = (wxWindow *) 0 ;
27134 bool result;
27135 PyObject * obj0 = 0 ;
27136 char *kwnames[] = {
27137 (char *) "self", NULL
27138 };
27139
27140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27142 if (SWIG_arg_fail(1)) SWIG_fail;
27143 {
27144 PyThreadState* __tstate = wxPyBeginAllowThreads();
27145 result = (bool)((wxWindow const *)arg1)->IsRetained();
27146
27147 wxPyEndAllowThreads(__tstate);
27148 if (PyErr_Occurred()) SWIG_fail;
27149 }
27150 {
27151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27152 }
27153 return resultobj;
27154 fail:
27155 return NULL;
27156 }
27157
27158
27159 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27160 PyObject *resultobj;
27161 wxWindow *arg1 = (wxWindow *) 0 ;
27162 long arg2 ;
27163 PyObject * obj0 = 0 ;
27164 PyObject * obj1 = 0 ;
27165 char *kwnames[] = {
27166 (char *) "self",(char *) "exStyle", NULL
27167 };
27168
27169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27171 if (SWIG_arg_fail(1)) SWIG_fail;
27172 {
27173 arg2 = (long)(SWIG_As_long(obj1));
27174 if (SWIG_arg_fail(2)) SWIG_fail;
27175 }
27176 {
27177 PyThreadState* __tstate = wxPyBeginAllowThreads();
27178 (arg1)->SetExtraStyle(arg2);
27179
27180 wxPyEndAllowThreads(__tstate);
27181 if (PyErr_Occurred()) SWIG_fail;
27182 }
27183 Py_INCREF(Py_None); resultobj = Py_None;
27184 return resultobj;
27185 fail:
27186 return NULL;
27187 }
27188
27189
27190 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27191 PyObject *resultobj;
27192 wxWindow *arg1 = (wxWindow *) 0 ;
27193 long result;
27194 PyObject * obj0 = 0 ;
27195 char *kwnames[] = {
27196 (char *) "self", NULL
27197 };
27198
27199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27201 if (SWIG_arg_fail(1)) SWIG_fail;
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27205
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 {
27210 resultobj = SWIG_From_long((long)(result));
27211 }
27212 return resultobj;
27213 fail:
27214 return NULL;
27215 }
27216
27217
27218 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27219 PyObject *resultobj;
27220 wxWindow *arg1 = (wxWindow *) 0 ;
27221 bool arg2 = (bool) true ;
27222 PyObject * obj0 = 0 ;
27223 PyObject * obj1 = 0 ;
27224 char *kwnames[] = {
27225 (char *) "self",(char *) "modal", NULL
27226 };
27227
27228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27230 if (SWIG_arg_fail(1)) SWIG_fail;
27231 if (obj1) {
27232 {
27233 arg2 = (bool)(SWIG_As_bool(obj1));
27234 if (SWIG_arg_fail(2)) SWIG_fail;
27235 }
27236 }
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 (arg1)->MakeModal(arg2);
27240
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 Py_INCREF(Py_None); resultobj = Py_None;
27245 return resultobj;
27246 fail:
27247 return NULL;
27248 }
27249
27250
27251 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27252 PyObject *resultobj;
27253 wxWindow *arg1 = (wxWindow *) 0 ;
27254 bool arg2 ;
27255 PyObject * obj0 = 0 ;
27256 PyObject * obj1 = 0 ;
27257 char *kwnames[] = {
27258 (char *) "self",(char *) "enableTheme", NULL
27259 };
27260
27261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27263 if (SWIG_arg_fail(1)) SWIG_fail;
27264 {
27265 arg2 = (bool)(SWIG_As_bool(obj1));
27266 if (SWIG_arg_fail(2)) SWIG_fail;
27267 }
27268 {
27269 PyThreadState* __tstate = wxPyBeginAllowThreads();
27270 (arg1)->SetThemeEnabled(arg2);
27271
27272 wxPyEndAllowThreads(__tstate);
27273 if (PyErr_Occurred()) SWIG_fail;
27274 }
27275 Py_INCREF(Py_None); resultobj = Py_None;
27276 return resultobj;
27277 fail:
27278 return NULL;
27279 }
27280
27281
27282 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27283 PyObject *resultobj;
27284 wxWindow *arg1 = (wxWindow *) 0 ;
27285 bool result;
27286 PyObject * obj0 = 0 ;
27287 char *kwnames[] = {
27288 (char *) "self", NULL
27289 };
27290
27291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27293 if (SWIG_arg_fail(1)) SWIG_fail;
27294 {
27295 PyThreadState* __tstate = wxPyBeginAllowThreads();
27296 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27297
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 {
27302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27303 }
27304 return resultobj;
27305 fail:
27306 return NULL;
27307 }
27308
27309
27310 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27311 PyObject *resultobj;
27312 wxWindow *arg1 = (wxWindow *) 0 ;
27313 PyObject * obj0 = 0 ;
27314 char *kwnames[] = {
27315 (char *) "self", NULL
27316 };
27317
27318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27320 if (SWIG_arg_fail(1)) SWIG_fail;
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 (arg1)->SetFocus();
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 Py_INCREF(Py_None); resultobj = Py_None;
27329 return resultobj;
27330 fail:
27331 return NULL;
27332 }
27333
27334
27335 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27336 PyObject *resultobj;
27337 wxWindow *arg1 = (wxWindow *) 0 ;
27338 PyObject * obj0 = 0 ;
27339 char *kwnames[] = {
27340 (char *) "self", NULL
27341 };
27342
27343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27345 if (SWIG_arg_fail(1)) SWIG_fail;
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 (arg1)->SetFocusFromKbd();
27349
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 Py_INCREF(Py_None); resultobj = Py_None;
27354 return resultobj;
27355 fail:
27356 return NULL;
27357 }
27358
27359
27360 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27361 PyObject *resultobj;
27362 wxWindow *result;
27363 char *kwnames[] = {
27364 NULL
27365 };
27366
27367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27368 {
27369 if (!wxPyCheckForApp()) SWIG_fail;
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 result = (wxWindow *)wxWindow::FindFocus();
27372
27373 wxPyEndAllowThreads(__tstate);
27374 if (PyErr_Occurred()) SWIG_fail;
27375 }
27376 {
27377 resultobj = wxPyMake_wxObject(result, 0);
27378 }
27379 return resultobj;
27380 fail:
27381 return NULL;
27382 }
27383
27384
27385 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27386 PyObject *resultobj;
27387 wxWindow *arg1 = (wxWindow *) 0 ;
27388 bool result;
27389 PyObject * obj0 = 0 ;
27390 char *kwnames[] = {
27391 (char *) "self", NULL
27392 };
27393
27394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27396 if (SWIG_arg_fail(1)) SWIG_fail;
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27400
27401 wxPyEndAllowThreads(__tstate);
27402 if (PyErr_Occurred()) SWIG_fail;
27403 }
27404 {
27405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27406 }
27407 return resultobj;
27408 fail:
27409 return NULL;
27410 }
27411
27412
27413 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27414 PyObject *resultobj;
27415 wxWindow *arg1 = (wxWindow *) 0 ;
27416 bool result;
27417 PyObject * obj0 = 0 ;
27418 char *kwnames[] = {
27419 (char *) "self", NULL
27420 };
27421
27422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27424 if (SWIG_arg_fail(1)) SWIG_fail;
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27428
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 {
27433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27434 }
27435 return resultobj;
27436 fail:
27437 return NULL;
27438 }
27439
27440
27441 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27442 PyObject *resultobj;
27443 wxWindow *arg1 = (wxWindow *) 0 ;
27444 wxWindow *result;
27445 PyObject * obj0 = 0 ;
27446 char *kwnames[] = {
27447 (char *) "self", NULL
27448 };
27449
27450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27452 if (SWIG_arg_fail(1)) SWIG_fail;
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27456
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 {
27461 resultobj = wxPyMake_wxObject(result, 0);
27462 }
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27470 PyObject *resultobj;
27471 wxWindow *arg1 = (wxWindow *) 0 ;
27472 wxWindow *arg2 = (wxWindow *) 0 ;
27473 wxWindow *result;
27474 PyObject * obj0 = 0 ;
27475 PyObject * obj1 = 0 ;
27476 char *kwnames[] = {
27477 (char *) "self",(char *) "child", NULL
27478 };
27479
27480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27482 if (SWIG_arg_fail(1)) SWIG_fail;
27483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(2)) SWIG_fail;
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = wxPyMake_wxObject(result, 0);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj;
27503 wxWindow *arg1 = (wxWindow *) 0 ;
27504 wxWindow *arg2 = (wxWindow *) 0 ;
27505 PyObject * obj0 = 0 ;
27506 PyObject * obj1 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self",(char *) "win", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(2)) SWIG_fail;
27516 {
27517 PyThreadState* __tstate = wxPyBeginAllowThreads();
27518 (arg1)->SetTmpDefaultItem(arg2);
27519
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 Py_INCREF(Py_None); resultobj = Py_None;
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27531 PyObject *resultobj;
27532 wxWindow *arg1 = (wxWindow *) 0 ;
27533 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27534 bool result;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 char *kwnames[] = {
27538 (char *) "self",(char *) "flags", NULL
27539 };
27540
27541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27543 if (SWIG_arg_fail(1)) SWIG_fail;
27544 if (obj1) {
27545 {
27546 arg2 = (int)(SWIG_As_int(obj1));
27547 if (SWIG_arg_fail(2)) SWIG_fail;
27548 }
27549 }
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 result = (bool)(arg1)->Navigate(arg2);
27553
27554 wxPyEndAllowThreads(__tstate);
27555 if (PyErr_Occurred()) SWIG_fail;
27556 }
27557 {
27558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27559 }
27560 return resultobj;
27561 fail:
27562 return NULL;
27563 }
27564
27565
27566 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27567 PyObject *resultobj;
27568 wxWindow *arg1 = (wxWindow *) 0 ;
27569 wxWindow *arg2 = (wxWindow *) 0 ;
27570 PyObject * obj0 = 0 ;
27571 PyObject * obj1 = 0 ;
27572 char *kwnames[] = {
27573 (char *) "self",(char *) "win", NULL
27574 };
27575
27576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27578 if (SWIG_arg_fail(1)) SWIG_fail;
27579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27580 if (SWIG_arg_fail(2)) SWIG_fail;
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 (arg1)->MoveAfterInTabOrder(arg2);
27584
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 Py_INCREF(Py_None); resultobj = Py_None;
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj;
27597 wxWindow *arg1 = (wxWindow *) 0 ;
27598 wxWindow *arg2 = (wxWindow *) 0 ;
27599 PyObject * obj0 = 0 ;
27600 PyObject * obj1 = 0 ;
27601 char *kwnames[] = {
27602 (char *) "self",(char *) "win", NULL
27603 };
27604
27605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27607 if (SWIG_arg_fail(1)) SWIG_fail;
27608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27609 if (SWIG_arg_fail(2)) SWIG_fail;
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 (arg1)->MoveBeforeInTabOrder(arg2);
27613
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 Py_INCREF(Py_None); resultobj = Py_None;
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27625 PyObject *resultobj;
27626 wxWindow *arg1 = (wxWindow *) 0 ;
27627 PyObject *result;
27628 PyObject * obj0 = 0 ;
27629 char *kwnames[] = {
27630 (char *) "self", NULL
27631 };
27632
27633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27635 if (SWIG_arg_fail(1)) SWIG_fail;
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (PyObject *)wxWindow_GetChildren(arg1);
27639
27640 wxPyEndAllowThreads(__tstate);
27641 if (PyErr_Occurred()) SWIG_fail;
27642 }
27643 resultobj = result;
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27651 PyObject *resultobj;
27652 wxWindow *arg1 = (wxWindow *) 0 ;
27653 wxWindow *result;
27654 PyObject * obj0 = 0 ;
27655 char *kwnames[] = {
27656 (char *) "self", NULL
27657 };
27658
27659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27661 if (SWIG_arg_fail(1)) SWIG_fail;
27662 {
27663 PyThreadState* __tstate = wxPyBeginAllowThreads();
27664 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27665
27666 wxPyEndAllowThreads(__tstate);
27667 if (PyErr_Occurred()) SWIG_fail;
27668 }
27669 {
27670 resultobj = wxPyMake_wxObject(result, 0);
27671 }
27672 return resultobj;
27673 fail:
27674 return NULL;
27675 }
27676
27677
27678 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27679 PyObject *resultobj;
27680 wxWindow *arg1 = (wxWindow *) 0 ;
27681 wxWindow *result;
27682 PyObject * obj0 = 0 ;
27683 char *kwnames[] = {
27684 (char *) "self", NULL
27685 };
27686
27687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27689 if (SWIG_arg_fail(1)) SWIG_fail;
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27693
27694 wxPyEndAllowThreads(__tstate);
27695 if (PyErr_Occurred()) SWIG_fail;
27696 }
27697 {
27698 resultobj = wxPyMake_wxObject(result, 0);
27699 }
27700 return resultobj;
27701 fail:
27702 return NULL;
27703 }
27704
27705
27706 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27707 PyObject *resultobj;
27708 wxWindow *arg1 = (wxWindow *) 0 ;
27709 bool result;
27710 PyObject * obj0 = 0 ;
27711 char *kwnames[] = {
27712 (char *) "self", NULL
27713 };
27714
27715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27717 if (SWIG_arg_fail(1)) SWIG_fail;
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27721
27722 wxPyEndAllowThreads(__tstate);
27723 if (PyErr_Occurred()) SWIG_fail;
27724 }
27725 {
27726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27727 }
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj;
27736 wxWindow *arg1 = (wxWindow *) 0 ;
27737 wxWindow *arg2 = (wxWindow *) 0 ;
27738 bool result;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char *kwnames[] = {
27742 (char *) "self",(char *) "newParent", NULL
27743 };
27744
27745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27747 if (SWIG_arg_fail(1)) SWIG_fail;
27748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27749 if (SWIG_arg_fail(2)) SWIG_fail;
27750 {
27751 PyThreadState* __tstate = wxPyBeginAllowThreads();
27752 result = (bool)(arg1)->Reparent(arg2);
27753
27754 wxPyEndAllowThreads(__tstate);
27755 if (PyErr_Occurred()) SWIG_fail;
27756 }
27757 {
27758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27759 }
27760 return resultobj;
27761 fail:
27762 return NULL;
27763 }
27764
27765
27766 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27767 PyObject *resultobj;
27768 wxWindow *arg1 = (wxWindow *) 0 ;
27769 wxWindow *arg2 = (wxWindow *) 0 ;
27770 PyObject * obj0 = 0 ;
27771 PyObject * obj1 = 0 ;
27772 char *kwnames[] = {
27773 (char *) "self",(char *) "child", NULL
27774 };
27775
27776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27778 if (SWIG_arg_fail(1)) SWIG_fail;
27779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27780 if (SWIG_arg_fail(2)) SWIG_fail;
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 (arg1)->AddChild(arg2);
27784
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 Py_INCREF(Py_None); resultobj = Py_None;
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27796 PyObject *resultobj;
27797 wxWindow *arg1 = (wxWindow *) 0 ;
27798 wxWindow *arg2 = (wxWindow *) 0 ;
27799 PyObject * obj0 = 0 ;
27800 PyObject * obj1 = 0 ;
27801 char *kwnames[] = {
27802 (char *) "self",(char *) "child", NULL
27803 };
27804
27805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27807 if (SWIG_arg_fail(1)) SWIG_fail;
27808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27809 if (SWIG_arg_fail(2)) SWIG_fail;
27810 {
27811 PyThreadState* __tstate = wxPyBeginAllowThreads();
27812 (arg1)->RemoveChild(arg2);
27813
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 Py_INCREF(Py_None); resultobj = Py_None;
27818 return resultobj;
27819 fail:
27820 return NULL;
27821 }
27822
27823
27824 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27825 PyObject *resultobj;
27826 wxWindow *arg1 = (wxWindow *) 0 ;
27827 long arg2 ;
27828 wxWindow *result;
27829 PyObject * obj0 = 0 ;
27830 PyObject * obj1 = 0 ;
27831 char *kwnames[] = {
27832 (char *) "self",(char *) "winid", NULL
27833 };
27834
27835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27837 if (SWIG_arg_fail(1)) SWIG_fail;
27838 {
27839 arg2 = (long)(SWIG_As_long(obj1));
27840 if (SWIG_arg_fail(2)) SWIG_fail;
27841 }
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (wxWindow *)(arg1)->FindWindow(arg2);
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 {
27850 resultobj = wxPyMake_wxObject(result, 0);
27851 }
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27859 PyObject *resultobj;
27860 wxWindow *arg1 = (wxWindow *) 0 ;
27861 wxString *arg2 = 0 ;
27862 wxWindow *result;
27863 bool temp2 = false ;
27864 PyObject * obj0 = 0 ;
27865 PyObject * obj1 = 0 ;
27866 char *kwnames[] = {
27867 (char *) "self",(char *) "name", NULL
27868 };
27869
27870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27872 if (SWIG_arg_fail(1)) SWIG_fail;
27873 {
27874 arg2 = wxString_in_helper(obj1);
27875 if (arg2 == NULL) SWIG_fail;
27876 temp2 = true;
27877 }
27878 {
27879 PyThreadState* __tstate = wxPyBeginAllowThreads();
27880 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27881
27882 wxPyEndAllowThreads(__tstate);
27883 if (PyErr_Occurred()) SWIG_fail;
27884 }
27885 {
27886 resultobj = wxPyMake_wxObject(result, 0);
27887 }
27888 {
27889 if (temp2)
27890 delete arg2;
27891 }
27892 return resultobj;
27893 fail:
27894 {
27895 if (temp2)
27896 delete arg2;
27897 }
27898 return NULL;
27899 }
27900
27901
27902 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj;
27904 wxWindow *arg1 = (wxWindow *) 0 ;
27905 wxEvtHandler *result;
27906 PyObject * obj0 = 0 ;
27907 char *kwnames[] = {
27908 (char *) "self", NULL
27909 };
27910
27911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27913 if (SWIG_arg_fail(1)) SWIG_fail;
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27917
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 resultobj = wxPyMake_wxObject(result, 0);
27923 }
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27931 PyObject *resultobj;
27932 wxWindow *arg1 = (wxWindow *) 0 ;
27933 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27934 PyObject * obj0 = 0 ;
27935 PyObject * obj1 = 0 ;
27936 char *kwnames[] = {
27937 (char *) "self",(char *) "handler", NULL
27938 };
27939
27940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27942 if (SWIG_arg_fail(1)) SWIG_fail;
27943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(2)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 (arg1)->SetEventHandler(arg2);
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 Py_INCREF(Py_None); resultobj = Py_None;
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj;
27961 wxWindow *arg1 = (wxWindow *) 0 ;
27962 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27963 PyObject * obj0 = 0 ;
27964 PyObject * obj1 = 0 ;
27965 char *kwnames[] = {
27966 (char *) "self",(char *) "handler", NULL
27967 };
27968
27969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27971 if (SWIG_arg_fail(1)) SWIG_fail;
27972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27973 if (SWIG_arg_fail(2)) SWIG_fail;
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 (arg1)->PushEventHandler(arg2);
27977
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 Py_INCREF(Py_None); resultobj = Py_None;
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj;
27990 wxWindow *arg1 = (wxWindow *) 0 ;
27991 bool arg2 = (bool) false ;
27992 wxEvtHandler *result;
27993 PyObject * obj0 = 0 ;
27994 PyObject * obj1 = 0 ;
27995 char *kwnames[] = {
27996 (char *) "self",(char *) "deleteHandler", NULL
27997 };
27998
27999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28001 if (SWIG_arg_fail(1)) SWIG_fail;
28002 if (obj1) {
28003 {
28004 arg2 = (bool)(SWIG_As_bool(obj1));
28005 if (SWIG_arg_fail(2)) SWIG_fail;
28006 }
28007 }
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28011
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 {
28016 resultobj = wxPyMake_wxObject(result, 0);
28017 }
28018 return resultobj;
28019 fail:
28020 return NULL;
28021 }
28022
28023
28024 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28025 PyObject *resultobj;
28026 wxWindow *arg1 = (wxWindow *) 0 ;
28027 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28028 bool result;
28029 PyObject * obj0 = 0 ;
28030 PyObject * obj1 = 0 ;
28031 char *kwnames[] = {
28032 (char *) "self",(char *) "handler", NULL
28033 };
28034
28035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28037 if (SWIG_arg_fail(1)) SWIG_fail;
28038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28039 if (SWIG_arg_fail(2)) SWIG_fail;
28040 {
28041 PyThreadState* __tstate = wxPyBeginAllowThreads();
28042 result = (bool)(arg1)->RemoveEventHandler(arg2);
28043
28044 wxPyEndAllowThreads(__tstate);
28045 if (PyErr_Occurred()) SWIG_fail;
28046 }
28047 {
28048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28049 }
28050 return resultobj;
28051 fail:
28052 return NULL;
28053 }
28054
28055
28056 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28057 PyObject *resultobj;
28058 wxWindow *arg1 = (wxWindow *) 0 ;
28059 wxValidator *arg2 = 0 ;
28060 PyObject * obj0 = 0 ;
28061 PyObject * obj1 = 0 ;
28062 char *kwnames[] = {
28063 (char *) "self",(char *) "validator", NULL
28064 };
28065
28066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28068 if (SWIG_arg_fail(1)) SWIG_fail;
28069 {
28070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28071 if (SWIG_arg_fail(2)) SWIG_fail;
28072 if (arg2 == NULL) {
28073 SWIG_null_ref("wxValidator");
28074 }
28075 if (SWIG_arg_fail(2)) SWIG_fail;
28076 }
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 (arg1)->SetValidator((wxValidator const &)*arg2);
28080
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 Py_INCREF(Py_None); resultobj = Py_None;
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28092 PyObject *resultobj;
28093 wxWindow *arg1 = (wxWindow *) 0 ;
28094 wxValidator *result;
28095 PyObject * obj0 = 0 ;
28096 char *kwnames[] = {
28097 (char *) "self", NULL
28098 };
28099
28100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28102 if (SWIG_arg_fail(1)) SWIG_fail;
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (wxValidator *)(arg1)->GetValidator();
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 resultobj = wxPyMake_wxObject(result, 0);
28112 }
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj;
28121 wxWindow *arg1 = (wxWindow *) 0 ;
28122 bool result;
28123 PyObject * obj0 = 0 ;
28124 char *kwnames[] = {
28125 (char *) "self", NULL
28126 };
28127
28128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28130 if (SWIG_arg_fail(1)) SWIG_fail;
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 result = (bool)(arg1)->Validate();
28134
28135 wxPyEndAllowThreads(__tstate);
28136 if (PyErr_Occurred()) SWIG_fail;
28137 }
28138 {
28139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28140 }
28141 return resultobj;
28142 fail:
28143 return NULL;
28144 }
28145
28146
28147 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj;
28149 wxWindow *arg1 = (wxWindow *) 0 ;
28150 bool result;
28151 PyObject * obj0 = 0 ;
28152 char *kwnames[] = {
28153 (char *) "self", NULL
28154 };
28155
28156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28158 if (SWIG_arg_fail(1)) SWIG_fail;
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 result = (bool)(arg1)->TransferDataToWindow();
28162
28163 wxPyEndAllowThreads(__tstate);
28164 if (PyErr_Occurred()) SWIG_fail;
28165 }
28166 {
28167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28168 }
28169 return resultobj;
28170 fail:
28171 return NULL;
28172 }
28173
28174
28175 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28176 PyObject *resultobj;
28177 wxWindow *arg1 = (wxWindow *) 0 ;
28178 bool result;
28179 PyObject * obj0 = 0 ;
28180 char *kwnames[] = {
28181 (char *) "self", NULL
28182 };
28183
28184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28186 if (SWIG_arg_fail(1)) SWIG_fail;
28187 {
28188 PyThreadState* __tstate = wxPyBeginAllowThreads();
28189 result = (bool)(arg1)->TransferDataFromWindow();
28190
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 {
28195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28196 }
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28204 PyObject *resultobj;
28205 wxWindow *arg1 = (wxWindow *) 0 ;
28206 PyObject * obj0 = 0 ;
28207 char *kwnames[] = {
28208 (char *) "self", NULL
28209 };
28210
28211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 (arg1)->InitDialog();
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 Py_INCREF(Py_None); resultobj = Py_None;
28222 return resultobj;
28223 fail:
28224 return NULL;
28225 }
28226
28227
28228 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28229 PyObject *resultobj;
28230 wxWindow *arg1 = (wxWindow *) 0 ;
28231 wxAcceleratorTable *arg2 = 0 ;
28232 PyObject * obj0 = 0 ;
28233 PyObject * obj1 = 0 ;
28234 char *kwnames[] = {
28235 (char *) "self",(char *) "accel", NULL
28236 };
28237
28238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28240 if (SWIG_arg_fail(1)) SWIG_fail;
28241 {
28242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28243 if (SWIG_arg_fail(2)) SWIG_fail;
28244 if (arg2 == NULL) {
28245 SWIG_null_ref("wxAcceleratorTable");
28246 }
28247 if (SWIG_arg_fail(2)) SWIG_fail;
28248 }
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28252
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 Py_INCREF(Py_None); resultobj = Py_None;
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj;
28265 wxWindow *arg1 = (wxWindow *) 0 ;
28266 wxAcceleratorTable *result;
28267 PyObject * obj0 = 0 ;
28268 char *kwnames[] = {
28269 (char *) "self", NULL
28270 };
28271
28272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28274 if (SWIG_arg_fail(1)) SWIG_fail;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28278
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28290 PyObject *resultobj;
28291 wxWindow *arg1 = (wxWindow *) 0 ;
28292 int arg2 ;
28293 int arg3 ;
28294 int arg4 ;
28295 bool result;
28296 PyObject * obj0 = 0 ;
28297 PyObject * obj1 = 0 ;
28298 PyObject * obj2 = 0 ;
28299 PyObject * obj3 = 0 ;
28300 char *kwnames[] = {
28301 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28302 };
28303
28304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28306 if (SWIG_arg_fail(1)) SWIG_fail;
28307 {
28308 arg2 = (int)(SWIG_As_int(obj1));
28309 if (SWIG_arg_fail(2)) SWIG_fail;
28310 }
28311 {
28312 arg3 = (int)(SWIG_As_int(obj2));
28313 if (SWIG_arg_fail(3)) SWIG_fail;
28314 }
28315 {
28316 arg4 = (int)(SWIG_As_int(obj3));
28317 if (SWIG_arg_fail(4)) SWIG_fail;
28318 }
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28322
28323 wxPyEndAllowThreads(__tstate);
28324 if (PyErr_Occurred()) SWIG_fail;
28325 }
28326 {
28327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28328 }
28329 return resultobj;
28330 fail:
28331 return NULL;
28332 }
28333
28334
28335 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28336 PyObject *resultobj;
28337 wxWindow *arg1 = (wxWindow *) 0 ;
28338 int arg2 ;
28339 bool result;
28340 PyObject * obj0 = 0 ;
28341 PyObject * obj1 = 0 ;
28342 char *kwnames[] = {
28343 (char *) "self",(char *) "hotkeyId", NULL
28344 };
28345
28346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28348 if (SWIG_arg_fail(1)) SWIG_fail;
28349 {
28350 arg2 = (int)(SWIG_As_int(obj1));
28351 if (SWIG_arg_fail(2)) SWIG_fail;
28352 }
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28356
28357 wxPyEndAllowThreads(__tstate);
28358 if (PyErr_Occurred()) SWIG_fail;
28359 }
28360 {
28361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28362 }
28363 return resultobj;
28364 fail:
28365 return NULL;
28366 }
28367
28368
28369 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28370 PyObject *resultobj;
28371 wxWindow *arg1 = (wxWindow *) 0 ;
28372 wxPoint *arg2 = 0 ;
28373 wxPoint result;
28374 wxPoint temp2 ;
28375 PyObject * obj0 = 0 ;
28376 PyObject * obj1 = 0 ;
28377 char *kwnames[] = {
28378 (char *) "self",(char *) "pt", NULL
28379 };
28380
28381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28383 if (SWIG_arg_fail(1)) SWIG_fail;
28384 {
28385 arg2 = &temp2;
28386 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28387 }
28388 {
28389 PyThreadState* __tstate = wxPyBeginAllowThreads();
28390 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28391
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 {
28396 wxPoint * resultptr;
28397 resultptr = new wxPoint((wxPoint &)(result));
28398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28399 }
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28407 PyObject *resultobj;
28408 wxWindow *arg1 = (wxWindow *) 0 ;
28409 wxSize *arg2 = 0 ;
28410 wxSize result;
28411 wxSize temp2 ;
28412 PyObject * obj0 = 0 ;
28413 PyObject * obj1 = 0 ;
28414 char *kwnames[] = {
28415 (char *) "self",(char *) "sz", NULL
28416 };
28417
28418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28420 if (SWIG_arg_fail(1)) SWIG_fail;
28421 {
28422 arg2 = &temp2;
28423 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28424 }
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28428
28429 wxPyEndAllowThreads(__tstate);
28430 if (PyErr_Occurred()) SWIG_fail;
28431 }
28432 {
28433 wxSize * resultptr;
28434 resultptr = new wxSize((wxSize &)(result));
28435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28436 }
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj;
28445 wxWindow *arg1 = (wxWindow *) 0 ;
28446 wxPoint *arg2 = 0 ;
28447 wxPoint result;
28448 wxPoint temp2 ;
28449 PyObject * obj0 = 0 ;
28450 PyObject * obj1 = 0 ;
28451 char *kwnames[] = {
28452 (char *) "self",(char *) "pt", NULL
28453 };
28454
28455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28457 if (SWIG_arg_fail(1)) SWIG_fail;
28458 {
28459 arg2 = &temp2;
28460 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28461 }
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28465
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 {
28470 wxPoint * resultptr;
28471 resultptr = new wxPoint((wxPoint &)(result));
28472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28473 }
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj;
28482 wxWindow *arg1 = (wxWindow *) 0 ;
28483 wxSize *arg2 = 0 ;
28484 wxSize result;
28485 wxSize temp2 ;
28486 PyObject * obj0 = 0 ;
28487 PyObject * obj1 = 0 ;
28488 char *kwnames[] = {
28489 (char *) "self",(char *) "sz", NULL
28490 };
28491
28492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28494 if (SWIG_arg_fail(1)) SWIG_fail;
28495 {
28496 arg2 = &temp2;
28497 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28498 }
28499 {
28500 PyThreadState* __tstate = wxPyBeginAllowThreads();
28501 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28502
28503 wxPyEndAllowThreads(__tstate);
28504 if (PyErr_Occurred()) SWIG_fail;
28505 }
28506 {
28507 wxSize * resultptr;
28508 resultptr = new wxSize((wxSize &)(result));
28509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28510 }
28511 return resultobj;
28512 fail:
28513 return NULL;
28514 }
28515
28516
28517 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28518 PyObject *resultobj;
28519 wxWindow *arg1 = (wxWindow *) 0 ;
28520 wxPoint *arg2 = 0 ;
28521 wxPoint result;
28522 wxPoint temp2 ;
28523 PyObject * obj0 = 0 ;
28524 PyObject * obj1 = 0 ;
28525 char *kwnames[] = {
28526 (char *) "self",(char *) "pt", NULL
28527 };
28528
28529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28531 if (SWIG_arg_fail(1)) SWIG_fail;
28532 {
28533 arg2 = &temp2;
28534 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28535 }
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28539
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 {
28544 wxPoint * resultptr;
28545 resultptr = new wxPoint((wxPoint &)(result));
28546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28547 }
28548 return resultobj;
28549 fail:
28550 return NULL;
28551 }
28552
28553
28554 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28555 PyObject *resultobj;
28556 wxWindow *arg1 = (wxWindow *) 0 ;
28557 wxSize *arg2 = 0 ;
28558 wxSize result;
28559 wxSize temp2 ;
28560 PyObject * obj0 = 0 ;
28561 PyObject * obj1 = 0 ;
28562 char *kwnames[] = {
28563 (char *) "self",(char *) "sz", NULL
28564 };
28565
28566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28568 if (SWIG_arg_fail(1)) SWIG_fail;
28569 {
28570 arg2 = &temp2;
28571 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28572 }
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28576
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 {
28581 wxSize * resultptr;
28582 resultptr = new wxSize((wxSize &)(result));
28583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28584 }
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28592 PyObject *resultobj;
28593 wxWindow *arg1 = (wxWindow *) 0 ;
28594 int arg2 ;
28595 int arg3 ;
28596 PyObject * obj0 = 0 ;
28597 PyObject * obj1 = 0 ;
28598 PyObject * obj2 = 0 ;
28599 char *kwnames[] = {
28600 (char *) "self",(char *) "x",(char *) "y", NULL
28601 };
28602
28603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28605 if (SWIG_arg_fail(1)) SWIG_fail;
28606 {
28607 arg2 = (int)(SWIG_As_int(obj1));
28608 if (SWIG_arg_fail(2)) SWIG_fail;
28609 }
28610 {
28611 arg3 = (int)(SWIG_As_int(obj2));
28612 if (SWIG_arg_fail(3)) SWIG_fail;
28613 }
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 (arg1)->WarpPointer(arg2,arg3);
28617
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 Py_INCREF(Py_None); resultobj = Py_None;
28622 return resultobj;
28623 fail:
28624 return NULL;
28625 }
28626
28627
28628 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28629 PyObject *resultobj;
28630 wxWindow *arg1 = (wxWindow *) 0 ;
28631 PyObject * obj0 = 0 ;
28632 char *kwnames[] = {
28633 (char *) "self", NULL
28634 };
28635
28636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28638 if (SWIG_arg_fail(1)) SWIG_fail;
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 (arg1)->CaptureMouse();
28642
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 Py_INCREF(Py_None); resultobj = Py_None;
28647 return resultobj;
28648 fail:
28649 return NULL;
28650 }
28651
28652
28653 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28654 PyObject *resultobj;
28655 wxWindow *arg1 = (wxWindow *) 0 ;
28656 PyObject * obj0 = 0 ;
28657 char *kwnames[] = {
28658 (char *) "self", NULL
28659 };
28660
28661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28663 if (SWIG_arg_fail(1)) SWIG_fail;
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 (arg1)->ReleaseMouse();
28667
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 Py_INCREF(Py_None); resultobj = Py_None;
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj;
28680 wxWindow *result;
28681 char *kwnames[] = {
28682 NULL
28683 };
28684
28685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28686 {
28687 if (!wxPyCheckForApp()) SWIG_fail;
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = (wxWindow *)wxWindow::GetCapture();
28690
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 {
28695 resultobj = wxPyMake_wxObject(result, 0);
28696 }
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj;
28705 wxWindow *arg1 = (wxWindow *) 0 ;
28706 bool result;
28707 PyObject * obj0 = 0 ;
28708 char *kwnames[] = {
28709 (char *) "self", NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28714 if (SWIG_arg_fail(1)) SWIG_fail;
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (bool)((wxWindow const *)arg1)->HasCapture();
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28724 }
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28732 PyObject *resultobj;
28733 wxWindow *arg1 = (wxWindow *) 0 ;
28734 bool arg2 = (bool) true ;
28735 wxRect *arg3 = (wxRect *) NULL ;
28736 PyObject * obj0 = 0 ;
28737 PyObject * obj1 = 0 ;
28738 PyObject * obj2 = 0 ;
28739 char *kwnames[] = {
28740 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28741 };
28742
28743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28745 if (SWIG_arg_fail(1)) SWIG_fail;
28746 if (obj1) {
28747 {
28748 arg2 = (bool)(SWIG_As_bool(obj1));
28749 if (SWIG_arg_fail(2)) SWIG_fail;
28750 }
28751 }
28752 if (obj2) {
28753 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28754 if (SWIG_arg_fail(3)) SWIG_fail;
28755 }
28756 {
28757 PyThreadState* __tstate = wxPyBeginAllowThreads();
28758 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28759
28760 wxPyEndAllowThreads(__tstate);
28761 if (PyErr_Occurred()) SWIG_fail;
28762 }
28763 Py_INCREF(Py_None); resultobj = Py_None;
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28771 PyObject *resultobj;
28772 wxWindow *arg1 = (wxWindow *) 0 ;
28773 wxRect *arg2 = 0 ;
28774 bool arg3 = (bool) true ;
28775 wxRect temp2 ;
28776 PyObject * obj0 = 0 ;
28777 PyObject * obj1 = 0 ;
28778 PyObject * obj2 = 0 ;
28779 char *kwnames[] = {
28780 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28781 };
28782
28783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28785 if (SWIG_arg_fail(1)) SWIG_fail;
28786 {
28787 arg2 = &temp2;
28788 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28789 }
28790 if (obj2) {
28791 {
28792 arg3 = (bool)(SWIG_As_bool(obj2));
28793 if (SWIG_arg_fail(3)) SWIG_fail;
28794 }
28795 }
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28799
28800 wxPyEndAllowThreads(__tstate);
28801 if (PyErr_Occurred()) SWIG_fail;
28802 }
28803 Py_INCREF(Py_None); resultobj = Py_None;
28804 return resultobj;
28805 fail:
28806 return NULL;
28807 }
28808
28809
28810 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28811 PyObject *resultobj;
28812 wxWindow *arg1 = (wxWindow *) 0 ;
28813 PyObject * obj0 = 0 ;
28814 char *kwnames[] = {
28815 (char *) "self", NULL
28816 };
28817
28818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28820 if (SWIG_arg_fail(1)) SWIG_fail;
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 (arg1)->Update();
28824
28825 wxPyEndAllowThreads(__tstate);
28826 if (PyErr_Occurred()) SWIG_fail;
28827 }
28828 Py_INCREF(Py_None); resultobj = Py_None;
28829 return resultobj;
28830 fail:
28831 return NULL;
28832 }
28833
28834
28835 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj;
28837 wxWindow *arg1 = (wxWindow *) 0 ;
28838 PyObject * obj0 = 0 ;
28839 char *kwnames[] = {
28840 (char *) "self", NULL
28841 };
28842
28843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28845 if (SWIG_arg_fail(1)) SWIG_fail;
28846 {
28847 PyThreadState* __tstate = wxPyBeginAllowThreads();
28848 (arg1)->ClearBackground();
28849
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 Py_INCREF(Py_None); resultobj = Py_None;
28854 return resultobj;
28855 fail:
28856 return NULL;
28857 }
28858
28859
28860 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28861 PyObject *resultobj;
28862 wxWindow *arg1 = (wxWindow *) 0 ;
28863 PyObject * obj0 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 (arg1)->Freeze();
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 Py_INCREF(Py_None); resultobj = Py_None;
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj;
28887 wxWindow *arg1 = (wxWindow *) 0 ;
28888 PyObject * obj0 = 0 ;
28889 char *kwnames[] = {
28890 (char *) "self", NULL
28891 };
28892
28893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28895 if (SWIG_arg_fail(1)) SWIG_fail;
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 (arg1)->Thaw();
28899
28900 wxPyEndAllowThreads(__tstate);
28901 if (PyErr_Occurred()) SWIG_fail;
28902 }
28903 Py_INCREF(Py_None); resultobj = Py_None;
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28911 PyObject *resultobj;
28912 wxWindow *arg1 = (wxWindow *) 0 ;
28913 wxDC *arg2 = 0 ;
28914 PyObject * obj0 = 0 ;
28915 PyObject * obj1 = 0 ;
28916 char *kwnames[] = {
28917 (char *) "self",(char *) "dc", NULL
28918 };
28919
28920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28922 if (SWIG_arg_fail(1)) SWIG_fail;
28923 {
28924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28925 if (SWIG_arg_fail(2)) SWIG_fail;
28926 if (arg2 == NULL) {
28927 SWIG_null_ref("wxDC");
28928 }
28929 if (SWIG_arg_fail(2)) SWIG_fail;
28930 }
28931 {
28932 PyThreadState* __tstate = wxPyBeginAllowThreads();
28933 (arg1)->PrepareDC(*arg2);
28934
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 Py_INCREF(Py_None); resultobj = Py_None;
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28946 PyObject *resultobj;
28947 wxWindow *arg1 = (wxWindow *) 0 ;
28948 wxRegion *result;
28949 PyObject * obj0 = 0 ;
28950 char *kwnames[] = {
28951 (char *) "self", NULL
28952 };
28953
28954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28956 if (SWIG_arg_fail(1)) SWIG_fail;
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 {
28960 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28961 result = (wxRegion *) &_result_ref;
28962 }
28963
28964 wxPyEndAllowThreads(__tstate);
28965 if (PyErr_Occurred()) SWIG_fail;
28966 }
28967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28968 return resultobj;
28969 fail:
28970 return NULL;
28971 }
28972
28973
28974 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28975 PyObject *resultobj;
28976 wxWindow *arg1 = (wxWindow *) 0 ;
28977 wxRect result;
28978 PyObject * obj0 = 0 ;
28979 char *kwnames[] = {
28980 (char *) "self", NULL
28981 };
28982
28983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28985 if (SWIG_arg_fail(1)) SWIG_fail;
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 {
28994 wxRect * resultptr;
28995 resultptr = new wxRect((wxRect &)(result));
28996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28997 }
28998 return resultobj;
28999 fail:
29000 return NULL;
29001 }
29002
29003
29004 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29005 PyObject *resultobj;
29006 wxWindow *arg1 = (wxWindow *) 0 ;
29007 int arg2 ;
29008 int arg3 ;
29009 int arg4 = (int) 1 ;
29010 int arg5 = (int) 1 ;
29011 bool result;
29012 PyObject * obj0 = 0 ;
29013 PyObject * obj1 = 0 ;
29014 PyObject * obj2 = 0 ;
29015 PyObject * obj3 = 0 ;
29016 PyObject * obj4 = 0 ;
29017 char *kwnames[] = {
29018 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29019 };
29020
29021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29023 if (SWIG_arg_fail(1)) SWIG_fail;
29024 {
29025 arg2 = (int)(SWIG_As_int(obj1));
29026 if (SWIG_arg_fail(2)) SWIG_fail;
29027 }
29028 {
29029 arg3 = (int)(SWIG_As_int(obj2));
29030 if (SWIG_arg_fail(3)) SWIG_fail;
29031 }
29032 if (obj3) {
29033 {
29034 arg4 = (int)(SWIG_As_int(obj3));
29035 if (SWIG_arg_fail(4)) SWIG_fail;
29036 }
29037 }
29038 if (obj4) {
29039 {
29040 arg5 = (int)(SWIG_As_int(obj4));
29041 if (SWIG_arg_fail(5)) SWIG_fail;
29042 }
29043 }
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 {
29052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29053 }
29054 return resultobj;
29055 fail:
29056 return NULL;
29057 }
29058
29059
29060 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29061 PyObject *resultobj;
29062 wxWindow *arg1 = (wxWindow *) 0 ;
29063 wxPoint *arg2 = 0 ;
29064 bool result;
29065 wxPoint temp2 ;
29066 PyObject * obj0 = 0 ;
29067 PyObject * obj1 = 0 ;
29068 char *kwnames[] = {
29069 (char *) "self",(char *) "pt", NULL
29070 };
29071
29072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29074 if (SWIG_arg_fail(1)) SWIG_fail;
29075 {
29076 arg2 = &temp2;
29077 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29078 }
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 {
29087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29088 }
29089 return resultobj;
29090 fail:
29091 return NULL;
29092 }
29093
29094
29095 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29096 PyObject *resultobj;
29097 wxWindow *arg1 = (wxWindow *) 0 ;
29098 wxRect *arg2 = 0 ;
29099 bool result;
29100 wxRect temp2 ;
29101 PyObject * obj0 = 0 ;
29102 PyObject * obj1 = 0 ;
29103 char *kwnames[] = {
29104 (char *) "self",(char *) "rect", NULL
29105 };
29106
29107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29109 if (SWIG_arg_fail(1)) SWIG_fail;
29110 {
29111 arg2 = &temp2;
29112 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29113 }
29114 {
29115 PyThreadState* __tstate = wxPyBeginAllowThreads();
29116 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29117
29118 wxPyEndAllowThreads(__tstate);
29119 if (PyErr_Occurred()) SWIG_fail;
29120 }
29121 {
29122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29123 }
29124 return resultobj;
29125 fail:
29126 return NULL;
29127 }
29128
29129
29130 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29131 PyObject *resultobj;
29132 wxWindow *arg1 = (wxWindow *) 0 ;
29133 wxVisualAttributes result;
29134 PyObject * obj0 = 0 ;
29135 char *kwnames[] = {
29136 (char *) "self", NULL
29137 };
29138
29139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29141 if (SWIG_arg_fail(1)) SWIG_fail;
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29145
29146 wxPyEndAllowThreads(__tstate);
29147 if (PyErr_Occurred()) SWIG_fail;
29148 }
29149 {
29150 wxVisualAttributes * resultptr;
29151 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29152 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29153 }
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29161 PyObject *resultobj;
29162 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29163 wxVisualAttributes result;
29164 PyObject * obj0 = 0 ;
29165 char *kwnames[] = {
29166 (char *) "variant", NULL
29167 };
29168
29169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29170 if (obj0) {
29171 {
29172 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29173 if (SWIG_arg_fail(1)) SWIG_fail;
29174 }
29175 }
29176 {
29177 if (!wxPyCheckForApp()) SWIG_fail;
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29180
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 {
29185 wxVisualAttributes * resultptr;
29186 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29187 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29188 }
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29196 PyObject *resultobj;
29197 wxWindow *arg1 = (wxWindow *) 0 ;
29198 wxColour *arg2 = 0 ;
29199 bool result;
29200 wxColour temp2 ;
29201 PyObject * obj0 = 0 ;
29202 PyObject * obj1 = 0 ;
29203 char *kwnames[] = {
29204 (char *) "self",(char *) "colour", NULL
29205 };
29206
29207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29209 if (SWIG_arg_fail(1)) SWIG_fail;
29210 {
29211 arg2 = &temp2;
29212 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29213 }
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 {
29222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29223 }
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj;
29232 wxWindow *arg1 = (wxWindow *) 0 ;
29233 wxColour *arg2 = 0 ;
29234 wxColour temp2 ;
29235 PyObject * obj0 = 0 ;
29236 PyObject * obj1 = 0 ;
29237 char *kwnames[] = {
29238 (char *) "self",(char *) "colour", NULL
29239 };
29240
29241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29243 if (SWIG_arg_fail(1)) SWIG_fail;
29244 {
29245 arg2 = &temp2;
29246 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29247 }
29248 {
29249 PyThreadState* __tstate = wxPyBeginAllowThreads();
29250 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29251
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 Py_INCREF(Py_None); resultobj = Py_None;
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29263 PyObject *resultobj;
29264 wxWindow *arg1 = (wxWindow *) 0 ;
29265 wxColour *arg2 = 0 ;
29266 bool result;
29267 wxColour temp2 ;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 char *kwnames[] = {
29271 (char *) "self",(char *) "colour", NULL
29272 };
29273
29274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29276 if (SWIG_arg_fail(1)) SWIG_fail;
29277 {
29278 arg2 = &temp2;
29279 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29280 }
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29284
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 {
29289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29290 }
29291 return resultobj;
29292 fail:
29293 return NULL;
29294 }
29295
29296
29297 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29298 PyObject *resultobj;
29299 wxWindow *arg1 = (wxWindow *) 0 ;
29300 wxColour *arg2 = 0 ;
29301 wxColour temp2 ;
29302 PyObject * obj0 = 0 ;
29303 PyObject * obj1 = 0 ;
29304 char *kwnames[] = {
29305 (char *) "self",(char *) "colour", NULL
29306 };
29307
29308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29310 if (SWIG_arg_fail(1)) SWIG_fail;
29311 {
29312 arg2 = &temp2;
29313 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29314 }
29315 {
29316 PyThreadState* __tstate = wxPyBeginAllowThreads();
29317 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29318
29319 wxPyEndAllowThreads(__tstate);
29320 if (PyErr_Occurred()) SWIG_fail;
29321 }
29322 Py_INCREF(Py_None); resultobj = Py_None;
29323 return resultobj;
29324 fail:
29325 return NULL;
29326 }
29327
29328
29329 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29330 PyObject *resultobj;
29331 wxWindow *arg1 = (wxWindow *) 0 ;
29332 wxColour result;
29333 PyObject * obj0 = 0 ;
29334 char *kwnames[] = {
29335 (char *) "self", NULL
29336 };
29337
29338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29340 if (SWIG_arg_fail(1)) SWIG_fail;
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29344
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 {
29349 wxColour * resultptr;
29350 resultptr = new wxColour((wxColour &)(result));
29351 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29352 }
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj;
29361 wxWindow *arg1 = (wxWindow *) 0 ;
29362 wxColour result;
29363 PyObject * obj0 = 0 ;
29364 char *kwnames[] = {
29365 (char *) "self", NULL
29366 };
29367
29368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29370 if (SWIG_arg_fail(1)) SWIG_fail;
29371 {
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 result = ((wxWindow const *)arg1)->GetForegroundColour();
29374
29375 wxPyEndAllowThreads(__tstate);
29376 if (PyErr_Occurred()) SWIG_fail;
29377 }
29378 {
29379 wxColour * resultptr;
29380 resultptr = new wxColour((wxColour &)(result));
29381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29382 }
29383 return resultobj;
29384 fail:
29385 return NULL;
29386 }
29387
29388
29389 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29390 PyObject *resultobj;
29391 wxWindow *arg1 = (wxWindow *) 0 ;
29392 wxBackgroundStyle arg2 ;
29393 bool result;
29394 PyObject * obj0 = 0 ;
29395 PyObject * obj1 = 0 ;
29396 char *kwnames[] = {
29397 (char *) "self",(char *) "style", NULL
29398 };
29399
29400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29402 if (SWIG_arg_fail(1)) SWIG_fail;
29403 {
29404 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29405 if (SWIG_arg_fail(2)) SWIG_fail;
29406 }
29407 {
29408 PyThreadState* __tstate = wxPyBeginAllowThreads();
29409 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29410
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 {
29415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29416 }
29417 return resultobj;
29418 fail:
29419 return NULL;
29420 }
29421
29422
29423 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29424 PyObject *resultobj;
29425 wxWindow *arg1 = (wxWindow *) 0 ;
29426 wxBackgroundStyle result;
29427 PyObject * obj0 = 0 ;
29428 char *kwnames[] = {
29429 (char *) "self", NULL
29430 };
29431
29432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29434 if (SWIG_arg_fail(1)) SWIG_fail;
29435 {
29436 PyThreadState* __tstate = wxPyBeginAllowThreads();
29437 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29438
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 resultobj = SWIG_From_int((result));
29443 return resultobj;
29444 fail:
29445 return NULL;
29446 }
29447
29448
29449 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29450 PyObject *resultobj;
29451 wxWindow *arg1 = (wxWindow *) 0 ;
29452 bool result;
29453 PyObject * obj0 = 0 ;
29454 char *kwnames[] = {
29455 (char *) "self", NULL
29456 };
29457
29458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29460 if (SWIG_arg_fail(1)) SWIG_fail;
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (bool)(arg1)->HasTransparentBackground();
29464
29465 wxPyEndAllowThreads(__tstate);
29466 if (PyErr_Occurred()) SWIG_fail;
29467 }
29468 {
29469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29470 }
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj;
29479 wxWindow *arg1 = (wxWindow *) 0 ;
29480 wxCursor *arg2 = 0 ;
29481 bool result;
29482 PyObject * obj0 = 0 ;
29483 PyObject * obj1 = 0 ;
29484 char *kwnames[] = {
29485 (char *) "self",(char *) "cursor", NULL
29486 };
29487
29488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29490 if (SWIG_arg_fail(1)) SWIG_fail;
29491 {
29492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29493 if (SWIG_arg_fail(2)) SWIG_fail;
29494 if (arg2 == NULL) {
29495 SWIG_null_ref("wxCursor");
29496 }
29497 if (SWIG_arg_fail(2)) SWIG_fail;
29498 }
29499 {
29500 PyThreadState* __tstate = wxPyBeginAllowThreads();
29501 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29502
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 {
29507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29508 }
29509 return resultobj;
29510 fail:
29511 return NULL;
29512 }
29513
29514
29515 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj;
29517 wxWindow *arg1 = (wxWindow *) 0 ;
29518 wxCursor result;
29519 PyObject * obj0 = 0 ;
29520 char *kwnames[] = {
29521 (char *) "self", NULL
29522 };
29523
29524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 result = (arg1)->GetCursor();
29530
29531 wxPyEndAllowThreads(__tstate);
29532 if (PyErr_Occurred()) SWIG_fail;
29533 }
29534 {
29535 wxCursor * resultptr;
29536 resultptr = new wxCursor((wxCursor &)(result));
29537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29538 }
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj;
29547 wxWindow *arg1 = (wxWindow *) 0 ;
29548 wxFont *arg2 = 0 ;
29549 bool result;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self",(char *) "font", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 {
29560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29561 if (SWIG_arg_fail(2)) SWIG_fail;
29562 if (arg2 == NULL) {
29563 SWIG_null_ref("wxFont");
29564 }
29565 if (SWIG_arg_fail(2)) SWIG_fail;
29566 }
29567 {
29568 PyThreadState* __tstate = wxPyBeginAllowThreads();
29569 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29570
29571 wxPyEndAllowThreads(__tstate);
29572 if (PyErr_Occurred()) SWIG_fail;
29573 }
29574 {
29575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29576 }
29577 return resultobj;
29578 fail:
29579 return NULL;
29580 }
29581
29582
29583 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29584 PyObject *resultobj;
29585 wxWindow *arg1 = (wxWindow *) 0 ;
29586 wxFont *arg2 = 0 ;
29587 PyObject * obj0 = 0 ;
29588 PyObject * obj1 = 0 ;
29589 char *kwnames[] = {
29590 (char *) "self",(char *) "font", NULL
29591 };
29592
29593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29595 if (SWIG_arg_fail(1)) SWIG_fail;
29596 {
29597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29598 if (SWIG_arg_fail(2)) SWIG_fail;
29599 if (arg2 == NULL) {
29600 SWIG_null_ref("wxFont");
29601 }
29602 if (SWIG_arg_fail(2)) SWIG_fail;
29603 }
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 (arg1)->SetOwnFont((wxFont const &)*arg2);
29607
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 Py_INCREF(Py_None); resultobj = Py_None;
29612 return resultobj;
29613 fail:
29614 return NULL;
29615 }
29616
29617
29618 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29619 PyObject *resultobj;
29620 wxWindow *arg1 = (wxWindow *) 0 ;
29621 wxFont result;
29622 PyObject * obj0 = 0 ;
29623 char *kwnames[] = {
29624 (char *) "self", NULL
29625 };
29626
29627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29629 if (SWIG_arg_fail(1)) SWIG_fail;
29630 {
29631 PyThreadState* __tstate = wxPyBeginAllowThreads();
29632 result = (arg1)->GetFont();
29633
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 {
29638 wxFont * resultptr;
29639 resultptr = new wxFont((wxFont &)(result));
29640 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29641 }
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj;
29650 wxWindow *arg1 = (wxWindow *) 0 ;
29651 wxCaret *arg2 = (wxCaret *) 0 ;
29652 PyObject * obj0 = 0 ;
29653 PyObject * obj1 = 0 ;
29654 char *kwnames[] = {
29655 (char *) "self",(char *) "caret", NULL
29656 };
29657
29658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29660 if (SWIG_arg_fail(1)) SWIG_fail;
29661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29662 if (SWIG_arg_fail(2)) SWIG_fail;
29663 {
29664 PyThreadState* __tstate = wxPyBeginAllowThreads();
29665 (arg1)->SetCaret(arg2);
29666
29667 wxPyEndAllowThreads(__tstate);
29668 if (PyErr_Occurred()) SWIG_fail;
29669 }
29670 Py_INCREF(Py_None); resultobj = Py_None;
29671 return resultobj;
29672 fail:
29673 return NULL;
29674 }
29675
29676
29677 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29678 PyObject *resultobj;
29679 wxWindow *arg1 = (wxWindow *) 0 ;
29680 wxCaret *result;
29681 PyObject * obj0 = 0 ;
29682 char *kwnames[] = {
29683 (char *) "self", NULL
29684 };
29685
29686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29688 if (SWIG_arg_fail(1)) SWIG_fail;
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29692
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29697 return resultobj;
29698 fail:
29699 return NULL;
29700 }
29701
29702
29703 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj;
29705 wxWindow *arg1 = (wxWindow *) 0 ;
29706 int result;
29707 PyObject * obj0 = 0 ;
29708 char *kwnames[] = {
29709 (char *) "self", NULL
29710 };
29711
29712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29714 if (SWIG_arg_fail(1)) SWIG_fail;
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29718
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 {
29723 resultobj = SWIG_From_int((int)(result));
29724 }
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj;
29733 wxWindow *arg1 = (wxWindow *) 0 ;
29734 int result;
29735 PyObject * obj0 = 0 ;
29736 char *kwnames[] = {
29737 (char *) "self", NULL
29738 };
29739
29740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29742 if (SWIG_arg_fail(1)) SWIG_fail;
29743 {
29744 PyThreadState* __tstate = wxPyBeginAllowThreads();
29745 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29746
29747 wxPyEndAllowThreads(__tstate);
29748 if (PyErr_Occurred()) SWIG_fail;
29749 }
29750 {
29751 resultobj = SWIG_From_int((int)(result));
29752 }
29753 return resultobj;
29754 fail:
29755 return NULL;
29756 }
29757
29758
29759 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29760 PyObject *resultobj;
29761 wxWindow *arg1 = (wxWindow *) 0 ;
29762 wxString *arg2 = 0 ;
29763 int *arg3 = (int *) 0 ;
29764 int *arg4 = (int *) 0 ;
29765 bool temp2 = false ;
29766 int temp3 ;
29767 int res3 = 0 ;
29768 int temp4 ;
29769 int res4 = 0 ;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 char *kwnames[] = {
29773 (char *) "self",(char *) "string", NULL
29774 };
29775
29776 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29777 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29780 if (SWIG_arg_fail(1)) SWIG_fail;
29781 {
29782 arg2 = wxString_in_helper(obj1);
29783 if (arg2 == NULL) SWIG_fail;
29784 temp2 = true;
29785 }
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29789
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 Py_INCREF(Py_None); resultobj = Py_None;
29794 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29795 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29796 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29797 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29798 {
29799 if (temp2)
29800 delete arg2;
29801 }
29802 return resultobj;
29803 fail:
29804 {
29805 if (temp2)
29806 delete arg2;
29807 }
29808 return NULL;
29809 }
29810
29811
29812 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29813 PyObject *resultobj;
29814 wxWindow *arg1 = (wxWindow *) 0 ;
29815 wxString *arg2 = 0 ;
29816 int *arg3 = (int *) 0 ;
29817 int *arg4 = (int *) 0 ;
29818 int *arg5 = (int *) 0 ;
29819 int *arg6 = (int *) 0 ;
29820 wxFont *arg7 = (wxFont *) NULL ;
29821 bool temp2 = false ;
29822 int temp3 ;
29823 int res3 = 0 ;
29824 int temp4 ;
29825 int res4 = 0 ;
29826 int temp5 ;
29827 int res5 = 0 ;
29828 int temp6 ;
29829 int res6 = 0 ;
29830 PyObject * obj0 = 0 ;
29831 PyObject * obj1 = 0 ;
29832 PyObject * obj2 = 0 ;
29833 char *kwnames[] = {
29834 (char *) "self",(char *) "string",(char *) "font", NULL
29835 };
29836
29837 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29838 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29839 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29840 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29843 if (SWIG_arg_fail(1)) SWIG_fail;
29844 {
29845 arg2 = wxString_in_helper(obj1);
29846 if (arg2 == NULL) SWIG_fail;
29847 temp2 = true;
29848 }
29849 if (obj2) {
29850 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29851 if (SWIG_arg_fail(7)) SWIG_fail;
29852 }
29853 {
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29856
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 Py_INCREF(Py_None); resultobj = Py_None;
29861 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29862 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29863 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29864 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29865 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29866 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29867 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29868 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29869 {
29870 if (temp2)
29871 delete arg2;
29872 }
29873 return resultobj;
29874 fail:
29875 {
29876 if (temp2)
29877 delete arg2;
29878 }
29879 return NULL;
29880 }
29881
29882
29883 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj;
29885 wxWindow *arg1 = (wxWindow *) 0 ;
29886 int *arg2 = (int *) 0 ;
29887 int *arg3 = (int *) 0 ;
29888 int temp2 ;
29889 int res2 = 0 ;
29890 int temp3 ;
29891 int res3 = 0 ;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 PyObject * obj2 = 0 ;
29895 char *kwnames[] = {
29896 (char *) "self",(char *) "x",(char *) "y", NULL
29897 };
29898
29899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29901 if (SWIG_arg_fail(1)) SWIG_fail;
29902 {
29903 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29904 temp2 = SWIG_As_int(obj1);
29905 if (SWIG_arg_fail(2)) SWIG_fail;
29906 arg2 = &temp2;
29907 res2 = SWIG_NEWOBJ;
29908 }
29909 }
29910 {
29911 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29912 temp3 = SWIG_As_int(obj2);
29913 if (SWIG_arg_fail(3)) SWIG_fail;
29914 arg3 = &temp3;
29915 res3 = SWIG_NEWOBJ;
29916 }
29917 }
29918 {
29919 PyThreadState* __tstate = wxPyBeginAllowThreads();
29920 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29921
29922 wxPyEndAllowThreads(__tstate);
29923 if (PyErr_Occurred()) SWIG_fail;
29924 }
29925 Py_INCREF(Py_None); resultobj = Py_None;
29926 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29927 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29928 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29929 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29937 PyObject *resultobj;
29938 wxWindow *arg1 = (wxWindow *) 0 ;
29939 int *arg2 = (int *) 0 ;
29940 int *arg3 = (int *) 0 ;
29941 int temp2 ;
29942 int res2 = 0 ;
29943 int temp3 ;
29944 int res3 = 0 ;
29945 PyObject * obj0 = 0 ;
29946 PyObject * obj1 = 0 ;
29947 PyObject * obj2 = 0 ;
29948 char *kwnames[] = {
29949 (char *) "self",(char *) "x",(char *) "y", NULL
29950 };
29951
29952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29954 if (SWIG_arg_fail(1)) SWIG_fail;
29955 {
29956 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29957 temp2 = SWIG_As_int(obj1);
29958 if (SWIG_arg_fail(2)) SWIG_fail;
29959 arg2 = &temp2;
29960 res2 = SWIG_NEWOBJ;
29961 }
29962 }
29963 {
29964 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29965 temp3 = SWIG_As_int(obj2);
29966 if (SWIG_arg_fail(3)) SWIG_fail;
29967 arg3 = &temp3;
29968 res3 = SWIG_NEWOBJ;
29969 }
29970 }
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 Py_INCREF(Py_None); resultobj = Py_None;
29979 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29980 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29981 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29982 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj;
29991 wxWindow *arg1 = (wxWindow *) 0 ;
29992 wxPoint *arg2 = 0 ;
29993 wxPoint result;
29994 wxPoint temp2 ;
29995 PyObject * obj0 = 0 ;
29996 PyObject * obj1 = 0 ;
29997 char *kwnames[] = {
29998 (char *) "self",(char *) "pt", NULL
29999 };
30000
30001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30003 if (SWIG_arg_fail(1)) SWIG_fail;
30004 {
30005 arg2 = &temp2;
30006 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30007 }
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30011
30012 wxPyEndAllowThreads(__tstate);
30013 if (PyErr_Occurred()) SWIG_fail;
30014 }
30015 {
30016 wxPoint * resultptr;
30017 resultptr = new wxPoint((wxPoint &)(result));
30018 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30019 }
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30027 PyObject *resultobj;
30028 wxWindow *arg1 = (wxWindow *) 0 ;
30029 wxPoint *arg2 = 0 ;
30030 wxPoint result;
30031 wxPoint temp2 ;
30032 PyObject * obj0 = 0 ;
30033 PyObject * obj1 = 0 ;
30034 char *kwnames[] = {
30035 (char *) "self",(char *) "pt", NULL
30036 };
30037
30038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30040 if (SWIG_arg_fail(1)) SWIG_fail;
30041 {
30042 arg2 = &temp2;
30043 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30044 }
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30048
30049 wxPyEndAllowThreads(__tstate);
30050 if (PyErr_Occurred()) SWIG_fail;
30051 }
30052 {
30053 wxPoint * resultptr;
30054 resultptr = new wxPoint((wxPoint &)(result));
30055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30056 }
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30064 PyObject *resultobj;
30065 wxWindow *arg1 = (wxWindow *) 0 ;
30066 int arg2 ;
30067 int arg3 ;
30068 wxHitTest result;
30069 PyObject * obj0 = 0 ;
30070 PyObject * obj1 = 0 ;
30071 PyObject * obj2 = 0 ;
30072 char *kwnames[] = {
30073 (char *) "self",(char *) "x",(char *) "y", NULL
30074 };
30075
30076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30078 if (SWIG_arg_fail(1)) SWIG_fail;
30079 {
30080 arg2 = (int)(SWIG_As_int(obj1));
30081 if (SWIG_arg_fail(2)) SWIG_fail;
30082 }
30083 {
30084 arg3 = (int)(SWIG_As_int(obj2));
30085 if (SWIG_arg_fail(3)) SWIG_fail;
30086 }
30087 {
30088 PyThreadState* __tstate = wxPyBeginAllowThreads();
30089 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30090
30091 wxPyEndAllowThreads(__tstate);
30092 if (PyErr_Occurred()) SWIG_fail;
30093 }
30094 resultobj = SWIG_From_int((result));
30095 return resultobj;
30096 fail:
30097 return NULL;
30098 }
30099
30100
30101 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30102 PyObject *resultobj;
30103 wxWindow *arg1 = (wxWindow *) 0 ;
30104 wxPoint *arg2 = 0 ;
30105 wxHitTest result;
30106 wxPoint temp2 ;
30107 PyObject * obj0 = 0 ;
30108 PyObject * obj1 = 0 ;
30109 char *kwnames[] = {
30110 (char *) "self",(char *) "pt", NULL
30111 };
30112
30113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30115 if (SWIG_arg_fail(1)) SWIG_fail;
30116 {
30117 arg2 = &temp2;
30118 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30119 }
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30123
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 resultobj = SWIG_From_int((result));
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30135 PyObject *resultobj;
30136 wxWindow *arg1 = (wxWindow *) 0 ;
30137 long arg2 ;
30138 wxBorder result;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141
30142 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30144 if (SWIG_arg_fail(1)) SWIG_fail;
30145 {
30146 arg2 = (long)(SWIG_As_long(obj1));
30147 if (SWIG_arg_fail(2)) SWIG_fail;
30148 }
30149 {
30150 PyThreadState* __tstate = wxPyBeginAllowThreads();
30151 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30152
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 resultobj = SWIG_From_int((result));
30157 return resultobj;
30158 fail:
30159 return NULL;
30160 }
30161
30162
30163 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30164 PyObject *resultobj;
30165 wxWindow *arg1 = (wxWindow *) 0 ;
30166 wxBorder result;
30167 PyObject * obj0 = 0 ;
30168
30169 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30171 if (SWIG_arg_fail(1)) SWIG_fail;
30172 {
30173 PyThreadState* __tstate = wxPyBeginAllowThreads();
30174 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30175
30176 wxPyEndAllowThreads(__tstate);
30177 if (PyErr_Occurred()) SWIG_fail;
30178 }
30179 resultobj = SWIG_From_int((result));
30180 return resultobj;
30181 fail:
30182 return NULL;
30183 }
30184
30185
30186 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30187 int argc;
30188 PyObject *argv[3];
30189 int ii;
30190
30191 argc = PyObject_Length(args);
30192 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30193 argv[ii] = PyTuple_GetItem(args,ii);
30194 }
30195 if (argc == 1) {
30196 int _v;
30197 {
30198 void *ptr;
30199 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30200 _v = 0;
30201 PyErr_Clear();
30202 } else {
30203 _v = 1;
30204 }
30205 }
30206 if (_v) {
30207 return _wrap_Window_GetBorder__SWIG_1(self,args);
30208 }
30209 }
30210 if (argc == 2) {
30211 int _v;
30212 {
30213 void *ptr;
30214 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30215 _v = 0;
30216 PyErr_Clear();
30217 } else {
30218 _v = 1;
30219 }
30220 }
30221 if (_v) {
30222 _v = SWIG_Check_long(argv[1]);
30223 if (_v) {
30224 return _wrap_Window_GetBorder__SWIG_0(self,args);
30225 }
30226 }
30227 }
30228
30229 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30230 return NULL;
30231 }
30232
30233
30234 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30235 PyObject *resultobj;
30236 wxWindow *arg1 = (wxWindow *) 0 ;
30237 long arg2 = (long) wxUPDATE_UI_NONE ;
30238 PyObject * obj0 = 0 ;
30239 PyObject * obj1 = 0 ;
30240 char *kwnames[] = {
30241 (char *) "self",(char *) "flags", NULL
30242 };
30243
30244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30246 if (SWIG_arg_fail(1)) SWIG_fail;
30247 if (obj1) {
30248 {
30249 arg2 = (long)(SWIG_As_long(obj1));
30250 if (SWIG_arg_fail(2)) SWIG_fail;
30251 }
30252 }
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 (arg1)->UpdateWindowUI(arg2);
30256
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 Py_INCREF(Py_None); resultobj = Py_None;
30261 return resultobj;
30262 fail:
30263 return NULL;
30264 }
30265
30266
30267 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30268 PyObject *resultobj;
30269 wxWindow *arg1 = (wxWindow *) 0 ;
30270 wxMenu *arg2 = (wxMenu *) 0 ;
30271 int arg3 = (int) -1 ;
30272 int arg4 = (int) -1 ;
30273 bool result;
30274 PyObject * obj0 = 0 ;
30275 PyObject * obj1 = 0 ;
30276 PyObject * obj2 = 0 ;
30277 PyObject * obj3 = 0 ;
30278 char *kwnames[] = {
30279 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30280 };
30281
30282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30284 if (SWIG_arg_fail(1)) SWIG_fail;
30285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30286 if (SWIG_arg_fail(2)) SWIG_fail;
30287 if (obj2) {
30288 {
30289 arg3 = (int)(SWIG_As_int(obj2));
30290 if (SWIG_arg_fail(3)) SWIG_fail;
30291 }
30292 }
30293 if (obj3) {
30294 {
30295 arg4 = (int)(SWIG_As_int(obj3));
30296 if (SWIG_arg_fail(4)) SWIG_fail;
30297 }
30298 }
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30302
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 {
30307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30308 }
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30316 PyObject *resultobj;
30317 wxWindow *arg1 = (wxWindow *) 0 ;
30318 wxMenu *arg2 = (wxMenu *) 0 ;
30319 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30320 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30321 bool result;
30322 wxPoint temp3 ;
30323 PyObject * obj0 = 0 ;
30324 PyObject * obj1 = 0 ;
30325 PyObject * obj2 = 0 ;
30326 char *kwnames[] = {
30327 (char *) "self",(char *) "menu",(char *) "pos", NULL
30328 };
30329
30330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30332 if (SWIG_arg_fail(1)) SWIG_fail;
30333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30334 if (SWIG_arg_fail(2)) SWIG_fail;
30335 if (obj2) {
30336 {
30337 arg3 = &temp3;
30338 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30339 }
30340 }
30341 {
30342 PyThreadState* __tstate = wxPyBeginAllowThreads();
30343 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30344
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 {
30349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30350 }
30351 return resultobj;
30352 fail:
30353 return NULL;
30354 }
30355
30356
30357 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30358 PyObject *resultobj;
30359 wxWindow *arg1 = (wxWindow *) 0 ;
30360 long result;
30361 PyObject * obj0 = 0 ;
30362 char *kwnames[] = {
30363 (char *) "self", NULL
30364 };
30365
30366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30368 if (SWIG_arg_fail(1)) SWIG_fail;
30369 {
30370 PyThreadState* __tstate = wxPyBeginAllowThreads();
30371 result = (long)wxWindow_GetHandle(arg1);
30372
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 {
30377 resultobj = SWIG_From_long((long)(result));
30378 }
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30386 PyObject *resultobj;
30387 wxWindow *arg1 = (wxWindow *) 0 ;
30388 long arg2 ;
30389 PyObject * obj0 = 0 ;
30390 PyObject * obj1 = 0 ;
30391 char *kwnames[] = {
30392 (char *) "self",(char *) "handle", NULL
30393 };
30394
30395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30397 if (SWIG_arg_fail(1)) SWIG_fail;
30398 {
30399 arg2 = (long)(SWIG_As_long(obj1));
30400 if (SWIG_arg_fail(2)) SWIG_fail;
30401 }
30402 {
30403 PyThreadState* __tstate = wxPyBeginAllowThreads();
30404 wxWindow_AssociateHandle(arg1,arg2);
30405
30406 wxPyEndAllowThreads(__tstate);
30407 if (PyErr_Occurred()) SWIG_fail;
30408 }
30409 Py_INCREF(Py_None); resultobj = Py_None;
30410 return resultobj;
30411 fail:
30412 return NULL;
30413 }
30414
30415
30416 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30417 PyObject *resultobj;
30418 wxWindow *arg1 = (wxWindow *) 0 ;
30419 PyObject * obj0 = 0 ;
30420 char *kwnames[] = {
30421 (char *) "self", NULL
30422 };
30423
30424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30426 if (SWIG_arg_fail(1)) SWIG_fail;
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 (arg1)->DissociateHandle();
30430
30431 wxPyEndAllowThreads(__tstate);
30432 if (PyErr_Occurred()) SWIG_fail;
30433 }
30434 Py_INCREF(Py_None); resultobj = Py_None;
30435 return resultobj;
30436 fail:
30437 return NULL;
30438 }
30439
30440
30441 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30442 PyObject *resultobj;
30443 wxWindow *arg1 = (wxWindow *) 0 ;
30444 int arg2 ;
30445 bool result;
30446 PyObject * obj0 = 0 ;
30447 PyObject * obj1 = 0 ;
30448 char *kwnames[] = {
30449 (char *) "self",(char *) "orient", NULL
30450 };
30451
30452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",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 = (int)(SWIG_As_int(obj1));
30457 if (SWIG_arg_fail(2)) SWIG_fail;
30458 }
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30462
30463 wxPyEndAllowThreads(__tstate);
30464 if (PyErr_Occurred()) SWIG_fail;
30465 }
30466 {
30467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30468 }
30469 return resultobj;
30470 fail:
30471 return NULL;
30472 }
30473
30474
30475 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30476 PyObject *resultobj;
30477 wxWindow *arg1 = (wxWindow *) 0 ;
30478 int arg2 ;
30479 int arg3 ;
30480 int arg4 ;
30481 int arg5 ;
30482 bool arg6 = (bool) true ;
30483 PyObject * obj0 = 0 ;
30484 PyObject * obj1 = 0 ;
30485 PyObject * obj2 = 0 ;
30486 PyObject * obj3 = 0 ;
30487 PyObject * obj4 = 0 ;
30488 PyObject * obj5 = 0 ;
30489 char *kwnames[] = {
30490 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30491 };
30492
30493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30495 if (SWIG_arg_fail(1)) SWIG_fail;
30496 {
30497 arg2 = (int)(SWIG_As_int(obj1));
30498 if (SWIG_arg_fail(2)) SWIG_fail;
30499 }
30500 {
30501 arg3 = (int)(SWIG_As_int(obj2));
30502 if (SWIG_arg_fail(3)) SWIG_fail;
30503 }
30504 {
30505 arg4 = (int)(SWIG_As_int(obj3));
30506 if (SWIG_arg_fail(4)) SWIG_fail;
30507 }
30508 {
30509 arg5 = (int)(SWIG_As_int(obj4));
30510 if (SWIG_arg_fail(5)) SWIG_fail;
30511 }
30512 if (obj5) {
30513 {
30514 arg6 = (bool)(SWIG_As_bool(obj5));
30515 if (SWIG_arg_fail(6)) SWIG_fail;
30516 }
30517 }
30518 {
30519 PyThreadState* __tstate = wxPyBeginAllowThreads();
30520 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30521
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 Py_INCREF(Py_None); resultobj = Py_None;
30526 return resultobj;
30527 fail:
30528 return NULL;
30529 }
30530
30531
30532 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30533 PyObject *resultobj;
30534 wxWindow *arg1 = (wxWindow *) 0 ;
30535 int arg2 ;
30536 int arg3 ;
30537 bool arg4 = (bool) true ;
30538 PyObject * obj0 = 0 ;
30539 PyObject * obj1 = 0 ;
30540 PyObject * obj2 = 0 ;
30541 PyObject * obj3 = 0 ;
30542 char *kwnames[] = {
30543 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30544 };
30545
30546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30548 if (SWIG_arg_fail(1)) SWIG_fail;
30549 {
30550 arg2 = (int)(SWIG_As_int(obj1));
30551 if (SWIG_arg_fail(2)) SWIG_fail;
30552 }
30553 {
30554 arg3 = (int)(SWIG_As_int(obj2));
30555 if (SWIG_arg_fail(3)) SWIG_fail;
30556 }
30557 if (obj3) {
30558 {
30559 arg4 = (bool)(SWIG_As_bool(obj3));
30560 if (SWIG_arg_fail(4)) SWIG_fail;
30561 }
30562 }
30563 {
30564 PyThreadState* __tstate = wxPyBeginAllowThreads();
30565 (arg1)->SetScrollPos(arg2,arg3,arg4);
30566
30567 wxPyEndAllowThreads(__tstate);
30568 if (PyErr_Occurred()) SWIG_fail;
30569 }
30570 Py_INCREF(Py_None); resultobj = Py_None;
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj;
30579 wxWindow *arg1 = (wxWindow *) 0 ;
30580 int arg2 ;
30581 int result;
30582 PyObject * obj0 = 0 ;
30583 PyObject * obj1 = 0 ;
30584 char *kwnames[] = {
30585 (char *) "self",(char *) "orientation", NULL
30586 };
30587
30588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30590 if (SWIG_arg_fail(1)) SWIG_fail;
30591 {
30592 arg2 = (int)(SWIG_As_int(obj1));
30593 if (SWIG_arg_fail(2)) SWIG_fail;
30594 }
30595 {
30596 PyThreadState* __tstate = wxPyBeginAllowThreads();
30597 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30598
30599 wxPyEndAllowThreads(__tstate);
30600 if (PyErr_Occurred()) SWIG_fail;
30601 }
30602 {
30603 resultobj = SWIG_From_int((int)(result));
30604 }
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30612 PyObject *resultobj;
30613 wxWindow *arg1 = (wxWindow *) 0 ;
30614 int arg2 ;
30615 int result;
30616 PyObject * obj0 = 0 ;
30617 PyObject * obj1 = 0 ;
30618 char *kwnames[] = {
30619 (char *) "self",(char *) "orientation", NULL
30620 };
30621
30622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30624 if (SWIG_arg_fail(1)) SWIG_fail;
30625 {
30626 arg2 = (int)(SWIG_As_int(obj1));
30627 if (SWIG_arg_fail(2)) SWIG_fail;
30628 }
30629 {
30630 PyThreadState* __tstate = wxPyBeginAllowThreads();
30631 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30632
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 {
30637 resultobj = SWIG_From_int((int)(result));
30638 }
30639 return resultobj;
30640 fail:
30641 return NULL;
30642 }
30643
30644
30645 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30646 PyObject *resultobj;
30647 wxWindow *arg1 = (wxWindow *) 0 ;
30648 int arg2 ;
30649 int result;
30650 PyObject * obj0 = 0 ;
30651 PyObject * obj1 = 0 ;
30652 char *kwnames[] = {
30653 (char *) "self",(char *) "orientation", NULL
30654 };
30655
30656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30658 if (SWIG_arg_fail(1)) SWIG_fail;
30659 {
30660 arg2 = (int)(SWIG_As_int(obj1));
30661 if (SWIG_arg_fail(2)) SWIG_fail;
30662 }
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30666
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 {
30671 resultobj = SWIG_From_int((int)(result));
30672 }
30673 return resultobj;
30674 fail:
30675 return NULL;
30676 }
30677
30678
30679 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30680 PyObject *resultobj;
30681 wxWindow *arg1 = (wxWindow *) 0 ;
30682 int arg2 ;
30683 int arg3 ;
30684 wxRect *arg4 = (wxRect *) NULL ;
30685 PyObject * obj0 = 0 ;
30686 PyObject * obj1 = 0 ;
30687 PyObject * obj2 = 0 ;
30688 PyObject * obj3 = 0 ;
30689 char *kwnames[] = {
30690 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30691 };
30692
30693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30695 if (SWIG_arg_fail(1)) SWIG_fail;
30696 {
30697 arg2 = (int)(SWIG_As_int(obj1));
30698 if (SWIG_arg_fail(2)) SWIG_fail;
30699 }
30700 {
30701 arg3 = (int)(SWIG_As_int(obj2));
30702 if (SWIG_arg_fail(3)) SWIG_fail;
30703 }
30704 if (obj3) {
30705 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30706 if (SWIG_arg_fail(4)) SWIG_fail;
30707 }
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30711
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 Py_INCREF(Py_None); resultobj = Py_None;
30716 return resultobj;
30717 fail:
30718 return NULL;
30719 }
30720
30721
30722 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30723 PyObject *resultobj;
30724 wxWindow *arg1 = (wxWindow *) 0 ;
30725 int arg2 ;
30726 bool result;
30727 PyObject * obj0 = 0 ;
30728 PyObject * obj1 = 0 ;
30729 char *kwnames[] = {
30730 (char *) "self",(char *) "lines", NULL
30731 };
30732
30733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30735 if (SWIG_arg_fail(1)) SWIG_fail;
30736 {
30737 arg2 = (int)(SWIG_As_int(obj1));
30738 if (SWIG_arg_fail(2)) SWIG_fail;
30739 }
30740 {
30741 PyThreadState* __tstate = wxPyBeginAllowThreads();
30742 result = (bool)(arg1)->ScrollLines(arg2);
30743
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 {
30748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30749 }
30750 return resultobj;
30751 fail:
30752 return NULL;
30753 }
30754
30755
30756 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30757 PyObject *resultobj;
30758 wxWindow *arg1 = (wxWindow *) 0 ;
30759 int arg2 ;
30760 bool result;
30761 PyObject * obj0 = 0 ;
30762 PyObject * obj1 = 0 ;
30763 char *kwnames[] = {
30764 (char *) "self",(char *) "pages", NULL
30765 };
30766
30767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30769 if (SWIG_arg_fail(1)) SWIG_fail;
30770 {
30771 arg2 = (int)(SWIG_As_int(obj1));
30772 if (SWIG_arg_fail(2)) SWIG_fail;
30773 }
30774 {
30775 PyThreadState* __tstate = wxPyBeginAllowThreads();
30776 result = (bool)(arg1)->ScrollPages(arg2);
30777
30778 wxPyEndAllowThreads(__tstate);
30779 if (PyErr_Occurred()) SWIG_fail;
30780 }
30781 {
30782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30783 }
30784 return resultobj;
30785 fail:
30786 return NULL;
30787 }
30788
30789
30790 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30791 PyObject *resultobj;
30792 wxWindow *arg1 = (wxWindow *) 0 ;
30793 bool result;
30794 PyObject * obj0 = 0 ;
30795 char *kwnames[] = {
30796 (char *) "self", NULL
30797 };
30798
30799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30801 if (SWIG_arg_fail(1)) SWIG_fail;
30802 {
30803 PyThreadState* __tstate = wxPyBeginAllowThreads();
30804 result = (bool)(arg1)->LineUp();
30805
30806 wxPyEndAllowThreads(__tstate);
30807 if (PyErr_Occurred()) SWIG_fail;
30808 }
30809 {
30810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30811 }
30812 return resultobj;
30813 fail:
30814 return NULL;
30815 }
30816
30817
30818 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30819 PyObject *resultobj;
30820 wxWindow *arg1 = (wxWindow *) 0 ;
30821 bool result;
30822 PyObject * obj0 = 0 ;
30823 char *kwnames[] = {
30824 (char *) "self", NULL
30825 };
30826
30827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30829 if (SWIG_arg_fail(1)) SWIG_fail;
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 result = (bool)(arg1)->LineDown();
30833
30834 wxPyEndAllowThreads(__tstate);
30835 if (PyErr_Occurred()) SWIG_fail;
30836 }
30837 {
30838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30839 }
30840 return resultobj;
30841 fail:
30842 return NULL;
30843 }
30844
30845
30846 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30847 PyObject *resultobj;
30848 wxWindow *arg1 = (wxWindow *) 0 ;
30849 bool result;
30850 PyObject * obj0 = 0 ;
30851 char *kwnames[] = {
30852 (char *) "self", NULL
30853 };
30854
30855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30857 if (SWIG_arg_fail(1)) SWIG_fail;
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = (bool)(arg1)->PageUp();
30861
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 {
30866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30867 }
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj;
30876 wxWindow *arg1 = (wxWindow *) 0 ;
30877 bool result;
30878 PyObject * obj0 = 0 ;
30879 char *kwnames[] = {
30880 (char *) "self", NULL
30881 };
30882
30883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30885 if (SWIG_arg_fail(1)) SWIG_fail;
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 result = (bool)(arg1)->PageDown();
30889
30890 wxPyEndAllowThreads(__tstate);
30891 if (PyErr_Occurred()) SWIG_fail;
30892 }
30893 {
30894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30895 }
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj;
30904 wxWindow *arg1 = (wxWindow *) 0 ;
30905 wxString *arg2 = 0 ;
30906 bool temp2 = false ;
30907 PyObject * obj0 = 0 ;
30908 PyObject * obj1 = 0 ;
30909 char *kwnames[] = {
30910 (char *) "self",(char *) "text", NULL
30911 };
30912
30913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30915 if (SWIG_arg_fail(1)) SWIG_fail;
30916 {
30917 arg2 = wxString_in_helper(obj1);
30918 if (arg2 == NULL) SWIG_fail;
30919 temp2 = true;
30920 }
30921 {
30922 PyThreadState* __tstate = wxPyBeginAllowThreads();
30923 (arg1)->SetHelpText((wxString const &)*arg2);
30924
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 Py_INCREF(Py_None); resultobj = Py_None;
30929 {
30930 if (temp2)
30931 delete arg2;
30932 }
30933 return resultobj;
30934 fail:
30935 {
30936 if (temp2)
30937 delete arg2;
30938 }
30939 return NULL;
30940 }
30941
30942
30943 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30944 PyObject *resultobj;
30945 wxWindow *arg1 = (wxWindow *) 0 ;
30946 wxString *arg2 = 0 ;
30947 bool temp2 = false ;
30948 PyObject * obj0 = 0 ;
30949 PyObject * obj1 = 0 ;
30950 char *kwnames[] = {
30951 (char *) "self",(char *) "text", NULL
30952 };
30953
30954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30956 if (SWIG_arg_fail(1)) SWIG_fail;
30957 {
30958 arg2 = wxString_in_helper(obj1);
30959 if (arg2 == NULL) SWIG_fail;
30960 temp2 = true;
30961 }
30962 {
30963 PyThreadState* __tstate = wxPyBeginAllowThreads();
30964 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30965
30966 wxPyEndAllowThreads(__tstate);
30967 if (PyErr_Occurred()) SWIG_fail;
30968 }
30969 Py_INCREF(Py_None); resultobj = Py_None;
30970 {
30971 if (temp2)
30972 delete arg2;
30973 }
30974 return resultobj;
30975 fail:
30976 {
30977 if (temp2)
30978 delete arg2;
30979 }
30980 return NULL;
30981 }
30982
30983
30984 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30985 PyObject *resultobj;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 wxString result;
30988 PyObject * obj0 = 0 ;
30989 char *kwnames[] = {
30990 (char *) "self", NULL
30991 };
30992
30993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30995 if (SWIG_arg_fail(1)) SWIG_fail;
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = ((wxWindow const *)arg1)->GetHelpText();
30999
31000 wxPyEndAllowThreads(__tstate);
31001 if (PyErr_Occurred()) SWIG_fail;
31002 }
31003 {
31004 #if wxUSE_UNICODE
31005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31006 #else
31007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31008 #endif
31009 }
31010 return resultobj;
31011 fail:
31012 return NULL;
31013 }
31014
31015
31016 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31017 PyObject *resultobj;
31018 wxWindow *arg1 = (wxWindow *) 0 ;
31019 wxString *arg2 = 0 ;
31020 bool temp2 = false ;
31021 PyObject * obj0 = 0 ;
31022 PyObject * obj1 = 0 ;
31023 char *kwnames[] = {
31024 (char *) "self",(char *) "tip", NULL
31025 };
31026
31027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31029 if (SWIG_arg_fail(1)) SWIG_fail;
31030 {
31031 arg2 = wxString_in_helper(obj1);
31032 if (arg2 == NULL) SWIG_fail;
31033 temp2 = true;
31034 }
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 (arg1)->SetToolTip((wxString const &)*arg2);
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 Py_INCREF(Py_None); resultobj = Py_None;
31043 {
31044 if (temp2)
31045 delete arg2;
31046 }
31047 return resultobj;
31048 fail:
31049 {
31050 if (temp2)
31051 delete arg2;
31052 }
31053 return NULL;
31054 }
31055
31056
31057 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31058 PyObject *resultobj;
31059 wxWindow *arg1 = (wxWindow *) 0 ;
31060 wxToolTip *arg2 = (wxToolTip *) 0 ;
31061 PyObject * obj0 = 0 ;
31062 PyObject * obj1 = 0 ;
31063 char *kwnames[] = {
31064 (char *) "self",(char *) "tip", NULL
31065 };
31066
31067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(2)) SWIG_fail;
31072 {
31073 PyThreadState* __tstate = wxPyBeginAllowThreads();
31074 (arg1)->SetToolTip(arg2);
31075
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 Py_INCREF(Py_None); resultobj = Py_None;
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj;
31088 wxWindow *arg1 = (wxWindow *) 0 ;
31089 wxToolTip *result;
31090 PyObject * obj0 = 0 ;
31091 char *kwnames[] = {
31092 (char *) "self", NULL
31093 };
31094
31095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31097 if (SWIG_arg_fail(1)) SWIG_fail;
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31101
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 {
31106 resultobj = wxPyMake_wxObject(result, 0);
31107 }
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj;
31116 wxWindow *arg1 = (wxWindow *) 0 ;
31117 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31118 PyObject * obj0 = 0 ;
31119 PyObject * obj1 = 0 ;
31120 char *kwnames[] = {
31121 (char *) "self",(char *) "dropTarget", NULL
31122 };
31123
31124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31126 if (SWIG_arg_fail(1)) SWIG_fail;
31127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31128 if (SWIG_arg_fail(2)) SWIG_fail;
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 (arg1)->SetDropTarget(arg2);
31132
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 Py_INCREF(Py_None); resultobj = Py_None;
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31144 PyObject *resultobj;
31145 wxWindow *arg1 = (wxWindow *) 0 ;
31146 wxPyDropTarget *result;
31147 PyObject * obj0 = 0 ;
31148 char *kwnames[] = {
31149 (char *) "self", NULL
31150 };
31151
31152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31154 if (SWIG_arg_fail(1)) SWIG_fail;
31155 {
31156 PyThreadState* __tstate = wxPyBeginAllowThreads();
31157 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31158
31159 wxPyEndAllowThreads(__tstate);
31160 if (PyErr_Occurred()) SWIG_fail;
31161 }
31162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31163 return resultobj;
31164 fail:
31165 return NULL;
31166 }
31167
31168
31169 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31170 PyObject *resultobj;
31171 wxWindow *arg1 = (wxWindow *) 0 ;
31172 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31173 PyObject * obj0 = 0 ;
31174 PyObject * obj1 = 0 ;
31175 char *kwnames[] = {
31176 (char *) "self",(char *) "constraints", NULL
31177 };
31178
31179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31181 if (SWIG_arg_fail(1)) SWIG_fail;
31182 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31183 if (SWIG_arg_fail(2)) SWIG_fail;
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 (arg1)->SetConstraints(arg2);
31187
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 Py_INCREF(Py_None); resultobj = Py_None;
31192 return resultobj;
31193 fail:
31194 return NULL;
31195 }
31196
31197
31198 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31199 PyObject *resultobj;
31200 wxWindow *arg1 = (wxWindow *) 0 ;
31201 wxLayoutConstraints *result;
31202 PyObject * obj0 = 0 ;
31203 char *kwnames[] = {
31204 (char *) "self", NULL
31205 };
31206
31207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31209 if (SWIG_arg_fail(1)) SWIG_fail;
31210 {
31211 PyThreadState* __tstate = wxPyBeginAllowThreads();
31212 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31213
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31225 PyObject *resultobj;
31226 wxWindow *arg1 = (wxWindow *) 0 ;
31227 bool arg2 ;
31228 PyObject * obj0 = 0 ;
31229 PyObject * obj1 = 0 ;
31230 char *kwnames[] = {
31231 (char *) "self",(char *) "autoLayout", NULL
31232 };
31233
31234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31236 if (SWIG_arg_fail(1)) SWIG_fail;
31237 {
31238 arg2 = (bool)(SWIG_As_bool(obj1));
31239 if (SWIG_arg_fail(2)) SWIG_fail;
31240 }
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 (arg1)->SetAutoLayout(arg2);
31244
31245 wxPyEndAllowThreads(__tstate);
31246 if (PyErr_Occurred()) SWIG_fail;
31247 }
31248 Py_INCREF(Py_None); resultobj = Py_None;
31249 return resultobj;
31250 fail:
31251 return NULL;
31252 }
31253
31254
31255 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj;
31257 wxWindow *arg1 = (wxWindow *) 0 ;
31258 bool result;
31259 PyObject * obj0 = 0 ;
31260 char *kwnames[] = {
31261 (char *) "self", NULL
31262 };
31263
31264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31266 if (SWIG_arg_fail(1)) SWIG_fail;
31267 {
31268 PyThreadState* __tstate = wxPyBeginAllowThreads();
31269 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31270
31271 wxPyEndAllowThreads(__tstate);
31272 if (PyErr_Occurred()) SWIG_fail;
31273 }
31274 {
31275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31276 }
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31284 PyObject *resultobj;
31285 wxWindow *arg1 = (wxWindow *) 0 ;
31286 bool result;
31287 PyObject * obj0 = 0 ;
31288 char *kwnames[] = {
31289 (char *) "self", NULL
31290 };
31291
31292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31294 if (SWIG_arg_fail(1)) SWIG_fail;
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = (bool)(arg1)->Layout();
31298
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 {
31303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31304 }
31305 return resultobj;
31306 fail:
31307 return NULL;
31308 }
31309
31310
31311 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31312 PyObject *resultobj;
31313 wxWindow *arg1 = (wxWindow *) 0 ;
31314 wxSizer *arg2 = (wxSizer *) 0 ;
31315 bool arg3 = (bool) true ;
31316 PyObject * obj0 = 0 ;
31317 PyObject * obj1 = 0 ;
31318 PyObject * obj2 = 0 ;
31319 char *kwnames[] = {
31320 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31321 };
31322
31323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31325 if (SWIG_arg_fail(1)) SWIG_fail;
31326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31327 if (SWIG_arg_fail(2)) SWIG_fail;
31328 if (obj2) {
31329 {
31330 arg3 = (bool)(SWIG_As_bool(obj2));
31331 if (SWIG_arg_fail(3)) SWIG_fail;
31332 }
31333 }
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 (arg1)->SetSizer(arg2,arg3);
31337
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 Py_INCREF(Py_None); resultobj = Py_None;
31342 return resultobj;
31343 fail:
31344 return NULL;
31345 }
31346
31347
31348 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31349 PyObject *resultobj;
31350 wxWindow *arg1 = (wxWindow *) 0 ;
31351 wxSizer *arg2 = (wxSizer *) 0 ;
31352 bool arg3 = (bool) true ;
31353 PyObject * obj0 = 0 ;
31354 PyObject * obj1 = 0 ;
31355 PyObject * obj2 = 0 ;
31356 char *kwnames[] = {
31357 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31358 };
31359
31360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31362 if (SWIG_arg_fail(1)) SWIG_fail;
31363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31364 if (SWIG_arg_fail(2)) SWIG_fail;
31365 if (obj2) {
31366 {
31367 arg3 = (bool)(SWIG_As_bool(obj2));
31368 if (SWIG_arg_fail(3)) SWIG_fail;
31369 }
31370 }
31371 {
31372 PyThreadState* __tstate = wxPyBeginAllowThreads();
31373 (arg1)->SetSizerAndFit(arg2,arg3);
31374
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 Py_INCREF(Py_None); resultobj = Py_None;
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31386 PyObject *resultobj;
31387 wxWindow *arg1 = (wxWindow *) 0 ;
31388 wxSizer *result;
31389 PyObject * obj0 = 0 ;
31390 char *kwnames[] = {
31391 (char *) "self", NULL
31392 };
31393
31394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31396 if (SWIG_arg_fail(1)) SWIG_fail;
31397 {
31398 PyThreadState* __tstate = wxPyBeginAllowThreads();
31399 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31400
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 {
31405 resultobj = wxPyMake_wxSizer(result, 0);
31406 }
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31414 PyObject *resultobj;
31415 wxWindow *arg1 = (wxWindow *) 0 ;
31416 wxSizer *arg2 = (wxSizer *) 0 ;
31417 PyObject * obj0 = 0 ;
31418 PyObject * obj1 = 0 ;
31419 char *kwnames[] = {
31420 (char *) "self",(char *) "sizer", NULL
31421 };
31422
31423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31425 if (SWIG_arg_fail(1)) SWIG_fail;
31426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31427 if (SWIG_arg_fail(2)) SWIG_fail;
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 (arg1)->SetContainingSizer(arg2);
31431
31432 wxPyEndAllowThreads(__tstate);
31433 if (PyErr_Occurred()) SWIG_fail;
31434 }
31435 Py_INCREF(Py_None); resultobj = Py_None;
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31443 PyObject *resultobj;
31444 wxWindow *arg1 = (wxWindow *) 0 ;
31445 wxSizer *result;
31446 PyObject * obj0 = 0 ;
31447 char *kwnames[] = {
31448 (char *) "self", NULL
31449 };
31450
31451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31453 if (SWIG_arg_fail(1)) SWIG_fail;
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31457
31458 wxPyEndAllowThreads(__tstate);
31459 if (PyErr_Occurred()) SWIG_fail;
31460 }
31461 {
31462 resultobj = wxPyMake_wxSizer(result, 0);
31463 }
31464 return resultobj;
31465 fail:
31466 return NULL;
31467 }
31468
31469
31470 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31471 PyObject *resultobj;
31472 wxWindow *arg1 = (wxWindow *) 0 ;
31473 PyObject * obj0 = 0 ;
31474 char *kwnames[] = {
31475 (char *) "self", NULL
31476 };
31477
31478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31480 if (SWIG_arg_fail(1)) SWIG_fail;
31481 {
31482 PyThreadState* __tstate = wxPyBeginAllowThreads();
31483 (arg1)->InheritAttributes();
31484
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 Py_INCREF(Py_None); resultobj = Py_None;
31489 return resultobj;
31490 fail:
31491 return NULL;
31492 }
31493
31494
31495 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31496 PyObject *resultobj;
31497 wxWindow *arg1 = (wxWindow *) 0 ;
31498 bool result;
31499 PyObject * obj0 = 0 ;
31500 char *kwnames[] = {
31501 (char *) "self", NULL
31502 };
31503
31504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31506 if (SWIG_arg_fail(1)) SWIG_fail;
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31510
31511 wxPyEndAllowThreads(__tstate);
31512 if (PyErr_Occurred()) SWIG_fail;
31513 }
31514 {
31515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31516 }
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31524 PyObject *obj;
31525 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31526 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31527 Py_INCREF(obj);
31528 return Py_BuildValue((char *)"");
31529 }
31530 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31531 PyObject *resultobj;
31532 long arg1 ;
31533 wxWindow *arg2 = (wxWindow *) NULL ;
31534 wxWindow *result;
31535 PyObject * obj0 = 0 ;
31536 PyObject * obj1 = 0 ;
31537 char *kwnames[] = {
31538 (char *) "id",(char *) "parent", NULL
31539 };
31540
31541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31542 {
31543 arg1 = (long)(SWIG_As_long(obj0));
31544 if (SWIG_arg_fail(1)) SWIG_fail;
31545 }
31546 if (obj1) {
31547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31548 if (SWIG_arg_fail(2)) SWIG_fail;
31549 }
31550 {
31551 if (!wxPyCheckForApp()) SWIG_fail;
31552 PyThreadState* __tstate = wxPyBeginAllowThreads();
31553 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31554
31555 wxPyEndAllowThreads(__tstate);
31556 if (PyErr_Occurred()) SWIG_fail;
31557 }
31558 {
31559 resultobj = wxPyMake_wxObject(result, 0);
31560 }
31561 return resultobj;
31562 fail:
31563 return NULL;
31564 }
31565
31566
31567 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31568 PyObject *resultobj;
31569 wxString *arg1 = 0 ;
31570 wxWindow *arg2 = (wxWindow *) NULL ;
31571 wxWindow *result;
31572 bool temp1 = false ;
31573 PyObject * obj0 = 0 ;
31574 PyObject * obj1 = 0 ;
31575 char *kwnames[] = {
31576 (char *) "name",(char *) "parent", NULL
31577 };
31578
31579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31580 {
31581 arg1 = wxString_in_helper(obj0);
31582 if (arg1 == NULL) SWIG_fail;
31583 temp1 = true;
31584 }
31585 if (obj1) {
31586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31587 if (SWIG_arg_fail(2)) SWIG_fail;
31588 }
31589 {
31590 if (!wxPyCheckForApp()) SWIG_fail;
31591 PyThreadState* __tstate = wxPyBeginAllowThreads();
31592 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31593
31594 wxPyEndAllowThreads(__tstate);
31595 if (PyErr_Occurred()) SWIG_fail;
31596 }
31597 {
31598 resultobj = wxPyMake_wxObject(result, 0);
31599 }
31600 {
31601 if (temp1)
31602 delete arg1;
31603 }
31604 return resultobj;
31605 fail:
31606 {
31607 if (temp1)
31608 delete arg1;
31609 }
31610 return NULL;
31611 }
31612
31613
31614 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj;
31616 wxString *arg1 = 0 ;
31617 wxWindow *arg2 = (wxWindow *) NULL ;
31618 wxWindow *result;
31619 bool temp1 = false ;
31620 PyObject * obj0 = 0 ;
31621 PyObject * obj1 = 0 ;
31622 char *kwnames[] = {
31623 (char *) "label",(char *) "parent", NULL
31624 };
31625
31626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31627 {
31628 arg1 = wxString_in_helper(obj0);
31629 if (arg1 == NULL) SWIG_fail;
31630 temp1 = true;
31631 }
31632 if (obj1) {
31633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31634 if (SWIG_arg_fail(2)) SWIG_fail;
31635 }
31636 {
31637 if (!wxPyCheckForApp()) SWIG_fail;
31638 PyThreadState* __tstate = wxPyBeginAllowThreads();
31639 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31640
31641 wxPyEndAllowThreads(__tstate);
31642 if (PyErr_Occurred()) SWIG_fail;
31643 }
31644 {
31645 resultobj = wxPyMake_wxObject(result, 0);
31646 }
31647 {
31648 if (temp1)
31649 delete arg1;
31650 }
31651 return resultobj;
31652 fail:
31653 {
31654 if (temp1)
31655 delete arg1;
31656 }
31657 return NULL;
31658 }
31659
31660
31661 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj;
31663 wxWindow *arg1 = (wxWindow *) 0 ;
31664 unsigned long arg2 ;
31665 wxWindow *result;
31666 PyObject * obj0 = 0 ;
31667 PyObject * obj1 = 0 ;
31668 char *kwnames[] = {
31669 (char *) "parent",(char *) "_hWnd", NULL
31670 };
31671
31672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31674 if (SWIG_arg_fail(1)) SWIG_fail;
31675 {
31676 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31677 if (SWIG_arg_fail(2)) SWIG_fail;
31678 }
31679 {
31680 PyThreadState* __tstate = wxPyBeginAllowThreads();
31681 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31682
31683 wxPyEndAllowThreads(__tstate);
31684 if (PyErr_Occurred()) SWIG_fail;
31685 }
31686 {
31687 resultobj = wxPyMake_wxObject(result, 0);
31688 }
31689 return resultobj;
31690 fail:
31691 return NULL;
31692 }
31693
31694
31695 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31696 PyObject *resultobj;
31697 wxValidator *result;
31698 char *kwnames[] = {
31699 NULL
31700 };
31701
31702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = (wxValidator *)new wxValidator();
31706
31707 wxPyEndAllowThreads(__tstate);
31708 if (PyErr_Occurred()) SWIG_fail;
31709 }
31710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31711 return resultobj;
31712 fail:
31713 return NULL;
31714 }
31715
31716
31717 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31718 PyObject *resultobj;
31719 wxValidator *arg1 = (wxValidator *) 0 ;
31720 wxValidator *result;
31721 PyObject * obj0 = 0 ;
31722 char *kwnames[] = {
31723 (char *) "self", NULL
31724 };
31725
31726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31728 if (SWIG_arg_fail(1)) SWIG_fail;
31729 {
31730 PyThreadState* __tstate = wxPyBeginAllowThreads();
31731 result = (wxValidator *)(arg1)->Clone();
31732
31733 wxPyEndAllowThreads(__tstate);
31734 if (PyErr_Occurred()) SWIG_fail;
31735 }
31736 {
31737 resultobj = wxPyMake_wxObject(result, 0);
31738 }
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj;
31747 wxValidator *arg1 = (wxValidator *) 0 ;
31748 wxWindow *arg2 = (wxWindow *) 0 ;
31749 bool result;
31750 PyObject * obj0 = 0 ;
31751 PyObject * obj1 = 0 ;
31752 char *kwnames[] = {
31753 (char *) "self",(char *) "parent", NULL
31754 };
31755
31756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31758 if (SWIG_arg_fail(1)) SWIG_fail;
31759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31760 if (SWIG_arg_fail(2)) SWIG_fail;
31761 {
31762 PyThreadState* __tstate = wxPyBeginAllowThreads();
31763 result = (bool)(arg1)->Validate(arg2);
31764
31765 wxPyEndAllowThreads(__tstate);
31766 if (PyErr_Occurred()) SWIG_fail;
31767 }
31768 {
31769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31770 }
31771 return resultobj;
31772 fail:
31773 return NULL;
31774 }
31775
31776
31777 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31778 PyObject *resultobj;
31779 wxValidator *arg1 = (wxValidator *) 0 ;
31780 bool result;
31781 PyObject * obj0 = 0 ;
31782 char *kwnames[] = {
31783 (char *) "self", NULL
31784 };
31785
31786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31788 if (SWIG_arg_fail(1)) SWIG_fail;
31789 {
31790 PyThreadState* __tstate = wxPyBeginAllowThreads();
31791 result = (bool)(arg1)->TransferToWindow();
31792
31793 wxPyEndAllowThreads(__tstate);
31794 if (PyErr_Occurred()) SWIG_fail;
31795 }
31796 {
31797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31798 }
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj;
31807 wxValidator *arg1 = (wxValidator *) 0 ;
31808 bool result;
31809 PyObject * obj0 = 0 ;
31810 char *kwnames[] = {
31811 (char *) "self", NULL
31812 };
31813
31814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31816 if (SWIG_arg_fail(1)) SWIG_fail;
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 result = (bool)(arg1)->TransferFromWindow();
31820
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 {
31825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31826 }
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31834 PyObject *resultobj;
31835 wxValidator *arg1 = (wxValidator *) 0 ;
31836 wxWindow *result;
31837 PyObject * obj0 = 0 ;
31838 char *kwnames[] = {
31839 (char *) "self", NULL
31840 };
31841
31842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31844 if (SWIG_arg_fail(1)) SWIG_fail;
31845 {
31846 PyThreadState* __tstate = wxPyBeginAllowThreads();
31847 result = (wxWindow *)(arg1)->GetWindow();
31848
31849 wxPyEndAllowThreads(__tstate);
31850 if (PyErr_Occurred()) SWIG_fail;
31851 }
31852 {
31853 resultobj = wxPyMake_wxObject(result, 0);
31854 }
31855 return resultobj;
31856 fail:
31857 return NULL;
31858 }
31859
31860
31861 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31862 PyObject *resultobj;
31863 wxValidator *arg1 = (wxValidator *) 0 ;
31864 wxWindow *arg2 = (wxWindow *) 0 ;
31865 PyObject * obj0 = 0 ;
31866 PyObject * obj1 = 0 ;
31867 char *kwnames[] = {
31868 (char *) "self",(char *) "window", NULL
31869 };
31870
31871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31873 if (SWIG_arg_fail(1)) SWIG_fail;
31874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31875 if (SWIG_arg_fail(2)) SWIG_fail;
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 (arg1)->SetWindow(arg2);
31879
31880 wxPyEndAllowThreads(__tstate);
31881 if (PyErr_Occurred()) SWIG_fail;
31882 }
31883 Py_INCREF(Py_None); resultobj = Py_None;
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj;
31892 bool result;
31893 char *kwnames[] = {
31894 NULL
31895 };
31896
31897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31898 {
31899 PyThreadState* __tstate = wxPyBeginAllowThreads();
31900 result = (bool)wxValidator::IsSilent();
31901
31902 wxPyEndAllowThreads(__tstate);
31903 if (PyErr_Occurred()) SWIG_fail;
31904 }
31905 {
31906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31907 }
31908 return resultobj;
31909 fail:
31910 return NULL;
31911 }
31912
31913
31914 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31915 PyObject *resultobj;
31916 int arg1 = (int) true ;
31917 PyObject * obj0 = 0 ;
31918 char *kwnames[] = {
31919 (char *) "doIt", NULL
31920 };
31921
31922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31923 if (obj0) {
31924 {
31925 arg1 = (int)(SWIG_As_int(obj0));
31926 if (SWIG_arg_fail(1)) SWIG_fail;
31927 }
31928 }
31929 {
31930 PyThreadState* __tstate = wxPyBeginAllowThreads();
31931 wxValidator::SetBellOnError(arg1);
31932
31933 wxPyEndAllowThreads(__tstate);
31934 if (PyErr_Occurred()) SWIG_fail;
31935 }
31936 Py_INCREF(Py_None); resultobj = Py_None;
31937 return resultobj;
31938 fail:
31939 return NULL;
31940 }
31941
31942
31943 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31944 PyObject *obj;
31945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31946 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31947 Py_INCREF(obj);
31948 return Py_BuildValue((char *)"");
31949 }
31950 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31951 PyObject *resultobj;
31952 wxPyValidator *result;
31953 char *kwnames[] = {
31954 NULL
31955 };
31956
31957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31958 {
31959 PyThreadState* __tstate = wxPyBeginAllowThreads();
31960 result = (wxPyValidator *)new wxPyValidator();
31961
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31966 return resultobj;
31967 fail:
31968 return NULL;
31969 }
31970
31971
31972 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31973 PyObject *resultobj;
31974 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31975 PyObject *arg2 = (PyObject *) 0 ;
31976 PyObject *arg3 = (PyObject *) 0 ;
31977 int arg4 = (int) true ;
31978 PyObject * obj0 = 0 ;
31979 PyObject * obj1 = 0 ;
31980 PyObject * obj2 = 0 ;
31981 PyObject * obj3 = 0 ;
31982 char *kwnames[] = {
31983 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31984 };
31985
31986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31988 if (SWIG_arg_fail(1)) SWIG_fail;
31989 arg2 = obj1;
31990 arg3 = obj2;
31991 if (obj3) {
31992 {
31993 arg4 = (int)(SWIG_As_int(obj3));
31994 if (SWIG_arg_fail(4)) SWIG_fail;
31995 }
31996 }
31997 {
31998 PyThreadState* __tstate = wxPyBeginAllowThreads();
31999 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32000
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 Py_INCREF(Py_None); resultobj = Py_None;
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32012 PyObject *obj;
32013 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32014 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32015 Py_INCREF(obj);
32016 return Py_BuildValue((char *)"");
32017 }
32018 static int _wrap_DefaultValidator_set(PyObject *) {
32019 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32020 return 1;
32021 }
32022
32023
32024 static PyObject *_wrap_DefaultValidator_get(void) {
32025 PyObject *pyobj;
32026
32027 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32028 return pyobj;
32029 }
32030
32031
32032 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32033 PyObject *resultobj;
32034 wxString const &arg1_defvalue = wxPyEmptyString ;
32035 wxString *arg1 = (wxString *) &arg1_defvalue ;
32036 long arg2 = (long) 0 ;
32037 wxMenu *result;
32038 bool temp1 = false ;
32039 PyObject * obj0 = 0 ;
32040 PyObject * obj1 = 0 ;
32041 char *kwnames[] = {
32042 (char *) "title",(char *) "style", NULL
32043 };
32044
32045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32046 if (obj0) {
32047 {
32048 arg1 = wxString_in_helper(obj0);
32049 if (arg1 == NULL) SWIG_fail;
32050 temp1 = true;
32051 }
32052 }
32053 if (obj1) {
32054 {
32055 arg2 = (long)(SWIG_As_long(obj1));
32056 if (SWIG_arg_fail(2)) SWIG_fail;
32057 }
32058 }
32059 {
32060 if (!wxPyCheckForApp()) SWIG_fail;
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32063
32064 wxPyEndAllowThreads(__tstate);
32065 if (PyErr_Occurred()) SWIG_fail;
32066 }
32067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32068 {
32069 if (temp1)
32070 delete arg1;
32071 }
32072 return resultobj;
32073 fail:
32074 {
32075 if (temp1)
32076 delete arg1;
32077 }
32078 return NULL;
32079 }
32080
32081
32082 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32083 PyObject *resultobj;
32084 wxMenu *arg1 = (wxMenu *) 0 ;
32085 int arg2 ;
32086 wxString *arg3 = 0 ;
32087 wxString const &arg4_defvalue = wxPyEmptyString ;
32088 wxString *arg4 = (wxString *) &arg4_defvalue ;
32089 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32090 wxMenuItem *result;
32091 bool temp3 = false ;
32092 bool temp4 = false ;
32093 PyObject * obj0 = 0 ;
32094 PyObject * obj1 = 0 ;
32095 PyObject * obj2 = 0 ;
32096 PyObject * obj3 = 0 ;
32097 PyObject * obj4 = 0 ;
32098 char *kwnames[] = {
32099 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32100 };
32101
32102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32104 if (SWIG_arg_fail(1)) SWIG_fail;
32105 {
32106 arg2 = (int)(SWIG_As_int(obj1));
32107 if (SWIG_arg_fail(2)) SWIG_fail;
32108 }
32109 {
32110 arg3 = wxString_in_helper(obj2);
32111 if (arg3 == NULL) SWIG_fail;
32112 temp3 = true;
32113 }
32114 if (obj3) {
32115 {
32116 arg4 = wxString_in_helper(obj3);
32117 if (arg4 == NULL) SWIG_fail;
32118 temp4 = true;
32119 }
32120 }
32121 if (obj4) {
32122 {
32123 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32124 if (SWIG_arg_fail(5)) SWIG_fail;
32125 }
32126 }
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32130
32131 wxPyEndAllowThreads(__tstate);
32132 if (PyErr_Occurred()) SWIG_fail;
32133 }
32134 {
32135 resultobj = wxPyMake_wxObject(result, 0);
32136 }
32137 {
32138 if (temp3)
32139 delete arg3;
32140 }
32141 {
32142 if (temp4)
32143 delete arg4;
32144 }
32145 return resultobj;
32146 fail:
32147 {
32148 if (temp3)
32149 delete arg3;
32150 }
32151 {
32152 if (temp4)
32153 delete arg4;
32154 }
32155 return NULL;
32156 }
32157
32158
32159 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32160 PyObject *resultobj;
32161 wxMenu *arg1 = (wxMenu *) 0 ;
32162 wxMenuItem *result;
32163 PyObject * obj0 = 0 ;
32164 char *kwnames[] = {
32165 (char *) "self", NULL
32166 };
32167
32168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32170 if (SWIG_arg_fail(1)) SWIG_fail;
32171 {
32172 PyThreadState* __tstate = wxPyBeginAllowThreads();
32173 result = (wxMenuItem *)(arg1)->AppendSeparator();
32174
32175 wxPyEndAllowThreads(__tstate);
32176 if (PyErr_Occurred()) SWIG_fail;
32177 }
32178 {
32179 resultobj = wxPyMake_wxObject(result, 0);
32180 }
32181 return resultobj;
32182 fail:
32183 return NULL;
32184 }
32185
32186
32187 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32188 PyObject *resultobj;
32189 wxMenu *arg1 = (wxMenu *) 0 ;
32190 int arg2 ;
32191 wxString *arg3 = 0 ;
32192 wxString const &arg4_defvalue = wxPyEmptyString ;
32193 wxString *arg4 = (wxString *) &arg4_defvalue ;
32194 wxMenuItem *result;
32195 bool temp3 = false ;
32196 bool temp4 = false ;
32197 PyObject * obj0 = 0 ;
32198 PyObject * obj1 = 0 ;
32199 PyObject * obj2 = 0 ;
32200 PyObject * obj3 = 0 ;
32201 char *kwnames[] = {
32202 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32203 };
32204
32205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32207 if (SWIG_arg_fail(1)) SWIG_fail;
32208 {
32209 arg2 = (int)(SWIG_As_int(obj1));
32210 if (SWIG_arg_fail(2)) SWIG_fail;
32211 }
32212 {
32213 arg3 = wxString_in_helper(obj2);
32214 if (arg3 == NULL) SWIG_fail;
32215 temp3 = true;
32216 }
32217 if (obj3) {
32218 {
32219 arg4 = wxString_in_helper(obj3);
32220 if (arg4 == NULL) SWIG_fail;
32221 temp4 = true;
32222 }
32223 }
32224 {
32225 PyThreadState* __tstate = wxPyBeginAllowThreads();
32226 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32227
32228 wxPyEndAllowThreads(__tstate);
32229 if (PyErr_Occurred()) SWIG_fail;
32230 }
32231 {
32232 resultobj = wxPyMake_wxObject(result, 0);
32233 }
32234 {
32235 if (temp3)
32236 delete arg3;
32237 }
32238 {
32239 if (temp4)
32240 delete arg4;
32241 }
32242 return resultobj;
32243 fail:
32244 {
32245 if (temp3)
32246 delete arg3;
32247 }
32248 {
32249 if (temp4)
32250 delete arg4;
32251 }
32252 return NULL;
32253 }
32254
32255
32256 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32257 PyObject *resultobj;
32258 wxMenu *arg1 = (wxMenu *) 0 ;
32259 int arg2 ;
32260 wxString *arg3 = 0 ;
32261 wxString const &arg4_defvalue = wxPyEmptyString ;
32262 wxString *arg4 = (wxString *) &arg4_defvalue ;
32263 wxMenuItem *result;
32264 bool temp3 = false ;
32265 bool temp4 = false ;
32266 PyObject * obj0 = 0 ;
32267 PyObject * obj1 = 0 ;
32268 PyObject * obj2 = 0 ;
32269 PyObject * obj3 = 0 ;
32270 char *kwnames[] = {
32271 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32272 };
32273
32274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32276 if (SWIG_arg_fail(1)) SWIG_fail;
32277 {
32278 arg2 = (int)(SWIG_As_int(obj1));
32279 if (SWIG_arg_fail(2)) SWIG_fail;
32280 }
32281 {
32282 arg3 = wxString_in_helper(obj2);
32283 if (arg3 == NULL) SWIG_fail;
32284 temp3 = true;
32285 }
32286 if (obj3) {
32287 {
32288 arg4 = wxString_in_helper(obj3);
32289 if (arg4 == NULL) SWIG_fail;
32290 temp4 = true;
32291 }
32292 }
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32296
32297 wxPyEndAllowThreads(__tstate);
32298 if (PyErr_Occurred()) SWIG_fail;
32299 }
32300 {
32301 resultobj = wxPyMake_wxObject(result, 0);
32302 }
32303 {
32304 if (temp3)
32305 delete arg3;
32306 }
32307 {
32308 if (temp4)
32309 delete arg4;
32310 }
32311 return resultobj;
32312 fail:
32313 {
32314 if (temp3)
32315 delete arg3;
32316 }
32317 {
32318 if (temp4)
32319 delete arg4;
32320 }
32321 return NULL;
32322 }
32323
32324
32325 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32326 PyObject *resultobj;
32327 wxMenu *arg1 = (wxMenu *) 0 ;
32328 int arg2 ;
32329 wxString *arg3 = 0 ;
32330 wxMenu *arg4 = (wxMenu *) 0 ;
32331 wxString const &arg5_defvalue = wxPyEmptyString ;
32332 wxString *arg5 = (wxString *) &arg5_defvalue ;
32333 wxMenuItem *result;
32334 bool temp3 = false ;
32335 bool temp5 = false ;
32336 PyObject * obj0 = 0 ;
32337 PyObject * obj1 = 0 ;
32338 PyObject * obj2 = 0 ;
32339 PyObject * obj3 = 0 ;
32340 PyObject * obj4 = 0 ;
32341 char *kwnames[] = {
32342 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32343 };
32344
32345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32347 if (SWIG_arg_fail(1)) SWIG_fail;
32348 {
32349 arg2 = (int)(SWIG_As_int(obj1));
32350 if (SWIG_arg_fail(2)) SWIG_fail;
32351 }
32352 {
32353 arg3 = wxString_in_helper(obj2);
32354 if (arg3 == NULL) SWIG_fail;
32355 temp3 = true;
32356 }
32357 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32358 if (SWIG_arg_fail(4)) SWIG_fail;
32359 if (obj4) {
32360 {
32361 arg5 = wxString_in_helper(obj4);
32362 if (arg5 == NULL) SWIG_fail;
32363 temp5 = true;
32364 }
32365 }
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32369
32370 wxPyEndAllowThreads(__tstate);
32371 if (PyErr_Occurred()) SWIG_fail;
32372 }
32373 {
32374 resultobj = wxPyMake_wxObject(result, 0);
32375 }
32376 {
32377 if (temp3)
32378 delete arg3;
32379 }
32380 {
32381 if (temp5)
32382 delete arg5;
32383 }
32384 return resultobj;
32385 fail:
32386 {
32387 if (temp3)
32388 delete arg3;
32389 }
32390 {
32391 if (temp5)
32392 delete arg5;
32393 }
32394 return NULL;
32395 }
32396
32397
32398 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32399 PyObject *resultobj;
32400 wxMenu *arg1 = (wxMenu *) 0 ;
32401 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32402 wxMenuItem *result;
32403 PyObject * obj0 = 0 ;
32404 PyObject * obj1 = 0 ;
32405 char *kwnames[] = {
32406 (char *) "self",(char *) "item", NULL
32407 };
32408
32409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32411 if (SWIG_arg_fail(1)) SWIG_fail;
32412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32413 if (SWIG_arg_fail(2)) SWIG_fail;
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 result = (wxMenuItem *)(arg1)->Append(arg2);
32417
32418 wxPyEndAllowThreads(__tstate);
32419 if (PyErr_Occurred()) SWIG_fail;
32420 }
32421 {
32422 resultobj = wxPyMake_wxObject(result, 0);
32423 }
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj;
32432 wxMenu *arg1 = (wxMenu *) 0 ;
32433 PyObject * obj0 = 0 ;
32434 char *kwnames[] = {
32435 (char *) "self", NULL
32436 };
32437
32438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32440 if (SWIG_arg_fail(1)) SWIG_fail;
32441 {
32442 PyThreadState* __tstate = wxPyBeginAllowThreads();
32443 (arg1)->Break();
32444
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 Py_INCREF(Py_None); resultobj = Py_None;
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32456 PyObject *resultobj;
32457 wxMenu *arg1 = (wxMenu *) 0 ;
32458 size_t arg2 ;
32459 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32460 wxMenuItem *result;
32461 PyObject * obj0 = 0 ;
32462 PyObject * obj1 = 0 ;
32463 PyObject * obj2 = 0 ;
32464 char *kwnames[] = {
32465 (char *) "self",(char *) "pos",(char *) "item", NULL
32466 };
32467
32468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32470 if (SWIG_arg_fail(1)) SWIG_fail;
32471 {
32472 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32473 if (SWIG_arg_fail(2)) SWIG_fail;
32474 }
32475 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32476 if (SWIG_arg_fail(3)) SWIG_fail;
32477 {
32478 PyThreadState* __tstate = wxPyBeginAllowThreads();
32479 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32480
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 {
32485 resultobj = wxPyMake_wxObject(result, 0);
32486 }
32487 return resultobj;
32488 fail:
32489 return NULL;
32490 }
32491
32492
32493 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32494 PyObject *resultobj;
32495 wxMenu *arg1 = (wxMenu *) 0 ;
32496 size_t arg2 ;
32497 int arg3 ;
32498 wxString *arg4 = 0 ;
32499 wxString const &arg5_defvalue = wxPyEmptyString ;
32500 wxString *arg5 = (wxString *) &arg5_defvalue ;
32501 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32502 wxMenuItem *result;
32503 bool temp4 = false ;
32504 bool temp5 = false ;
32505 PyObject * obj0 = 0 ;
32506 PyObject * obj1 = 0 ;
32507 PyObject * obj2 = 0 ;
32508 PyObject * obj3 = 0 ;
32509 PyObject * obj4 = 0 ;
32510 PyObject * obj5 = 0 ;
32511 char *kwnames[] = {
32512 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32513 };
32514
32515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32517 if (SWIG_arg_fail(1)) SWIG_fail;
32518 {
32519 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32520 if (SWIG_arg_fail(2)) SWIG_fail;
32521 }
32522 {
32523 arg3 = (int)(SWIG_As_int(obj2));
32524 if (SWIG_arg_fail(3)) SWIG_fail;
32525 }
32526 {
32527 arg4 = wxString_in_helper(obj3);
32528 if (arg4 == NULL) SWIG_fail;
32529 temp4 = true;
32530 }
32531 if (obj4) {
32532 {
32533 arg5 = wxString_in_helper(obj4);
32534 if (arg5 == NULL) SWIG_fail;
32535 temp5 = true;
32536 }
32537 }
32538 if (obj5) {
32539 {
32540 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32541 if (SWIG_arg_fail(6)) SWIG_fail;
32542 }
32543 }
32544 {
32545 PyThreadState* __tstate = wxPyBeginAllowThreads();
32546 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32547
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 {
32552 resultobj = wxPyMake_wxObject(result, 0);
32553 }
32554 {
32555 if (temp4)
32556 delete arg4;
32557 }
32558 {
32559 if (temp5)
32560 delete arg5;
32561 }
32562 return resultobj;
32563 fail:
32564 {
32565 if (temp4)
32566 delete arg4;
32567 }
32568 {
32569 if (temp5)
32570 delete arg5;
32571 }
32572 return NULL;
32573 }
32574
32575
32576 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32577 PyObject *resultobj;
32578 wxMenu *arg1 = (wxMenu *) 0 ;
32579 size_t arg2 ;
32580 wxMenuItem *result;
32581 PyObject * obj0 = 0 ;
32582 PyObject * obj1 = 0 ;
32583 char *kwnames[] = {
32584 (char *) "self",(char *) "pos", NULL
32585 };
32586
32587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32589 if (SWIG_arg_fail(1)) SWIG_fail;
32590 {
32591 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32592 if (SWIG_arg_fail(2)) SWIG_fail;
32593 }
32594 {
32595 PyThreadState* __tstate = wxPyBeginAllowThreads();
32596 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32597
32598 wxPyEndAllowThreads(__tstate);
32599 if (PyErr_Occurred()) SWIG_fail;
32600 }
32601 {
32602 resultobj = wxPyMake_wxObject(result, 0);
32603 }
32604 return resultobj;
32605 fail:
32606 return NULL;
32607 }
32608
32609
32610 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32611 PyObject *resultobj;
32612 wxMenu *arg1 = (wxMenu *) 0 ;
32613 size_t arg2 ;
32614 int arg3 ;
32615 wxString *arg4 = 0 ;
32616 wxString const &arg5_defvalue = wxPyEmptyString ;
32617 wxString *arg5 = (wxString *) &arg5_defvalue ;
32618 wxMenuItem *result;
32619 bool temp4 = false ;
32620 bool temp5 = false ;
32621 PyObject * obj0 = 0 ;
32622 PyObject * obj1 = 0 ;
32623 PyObject * obj2 = 0 ;
32624 PyObject * obj3 = 0 ;
32625 PyObject * obj4 = 0 ;
32626 char *kwnames[] = {
32627 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32628 };
32629
32630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32632 if (SWIG_arg_fail(1)) SWIG_fail;
32633 {
32634 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32635 if (SWIG_arg_fail(2)) SWIG_fail;
32636 }
32637 {
32638 arg3 = (int)(SWIG_As_int(obj2));
32639 if (SWIG_arg_fail(3)) SWIG_fail;
32640 }
32641 {
32642 arg4 = wxString_in_helper(obj3);
32643 if (arg4 == NULL) SWIG_fail;
32644 temp4 = true;
32645 }
32646 if (obj4) {
32647 {
32648 arg5 = wxString_in_helper(obj4);
32649 if (arg5 == NULL) SWIG_fail;
32650 temp5 = true;
32651 }
32652 }
32653 {
32654 PyThreadState* __tstate = wxPyBeginAllowThreads();
32655 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32656
32657 wxPyEndAllowThreads(__tstate);
32658 if (PyErr_Occurred()) SWIG_fail;
32659 }
32660 {
32661 resultobj = wxPyMake_wxObject(result, 0);
32662 }
32663 {
32664 if (temp4)
32665 delete arg4;
32666 }
32667 {
32668 if (temp5)
32669 delete arg5;
32670 }
32671 return resultobj;
32672 fail:
32673 {
32674 if (temp4)
32675 delete arg4;
32676 }
32677 {
32678 if (temp5)
32679 delete arg5;
32680 }
32681 return NULL;
32682 }
32683
32684
32685 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32686 PyObject *resultobj;
32687 wxMenu *arg1 = (wxMenu *) 0 ;
32688 size_t arg2 ;
32689 int arg3 ;
32690 wxString *arg4 = 0 ;
32691 wxString const &arg5_defvalue = wxPyEmptyString ;
32692 wxString *arg5 = (wxString *) &arg5_defvalue ;
32693 wxMenuItem *result;
32694 bool temp4 = false ;
32695 bool temp5 = false ;
32696 PyObject * obj0 = 0 ;
32697 PyObject * obj1 = 0 ;
32698 PyObject * obj2 = 0 ;
32699 PyObject * obj3 = 0 ;
32700 PyObject * obj4 = 0 ;
32701 char *kwnames[] = {
32702 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32703 };
32704
32705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32707 if (SWIG_arg_fail(1)) SWIG_fail;
32708 {
32709 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32710 if (SWIG_arg_fail(2)) SWIG_fail;
32711 }
32712 {
32713 arg3 = (int)(SWIG_As_int(obj2));
32714 if (SWIG_arg_fail(3)) SWIG_fail;
32715 }
32716 {
32717 arg4 = wxString_in_helper(obj3);
32718 if (arg4 == NULL) SWIG_fail;
32719 temp4 = true;
32720 }
32721 if (obj4) {
32722 {
32723 arg5 = wxString_in_helper(obj4);
32724 if (arg5 == NULL) SWIG_fail;
32725 temp5 = true;
32726 }
32727 }
32728 {
32729 PyThreadState* __tstate = wxPyBeginAllowThreads();
32730 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32731
32732 wxPyEndAllowThreads(__tstate);
32733 if (PyErr_Occurred()) SWIG_fail;
32734 }
32735 {
32736 resultobj = wxPyMake_wxObject(result, 0);
32737 }
32738 {
32739 if (temp4)
32740 delete arg4;
32741 }
32742 {
32743 if (temp5)
32744 delete arg5;
32745 }
32746 return resultobj;
32747 fail:
32748 {
32749 if (temp4)
32750 delete arg4;
32751 }
32752 {
32753 if (temp5)
32754 delete arg5;
32755 }
32756 return NULL;
32757 }
32758
32759
32760 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32761 PyObject *resultobj;
32762 wxMenu *arg1 = (wxMenu *) 0 ;
32763 size_t arg2 ;
32764 int arg3 ;
32765 wxString *arg4 = 0 ;
32766 wxMenu *arg5 = (wxMenu *) 0 ;
32767 wxString const &arg6_defvalue = wxPyEmptyString ;
32768 wxString *arg6 = (wxString *) &arg6_defvalue ;
32769 wxMenuItem *result;
32770 bool temp4 = false ;
32771 bool temp6 = false ;
32772 PyObject * obj0 = 0 ;
32773 PyObject * obj1 = 0 ;
32774 PyObject * obj2 = 0 ;
32775 PyObject * obj3 = 0 ;
32776 PyObject * obj4 = 0 ;
32777 PyObject * obj5 = 0 ;
32778 char *kwnames[] = {
32779 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32780 };
32781
32782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32784 if (SWIG_arg_fail(1)) SWIG_fail;
32785 {
32786 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32787 if (SWIG_arg_fail(2)) SWIG_fail;
32788 }
32789 {
32790 arg3 = (int)(SWIG_As_int(obj2));
32791 if (SWIG_arg_fail(3)) SWIG_fail;
32792 }
32793 {
32794 arg4 = wxString_in_helper(obj3);
32795 if (arg4 == NULL) SWIG_fail;
32796 temp4 = true;
32797 }
32798 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32799 if (SWIG_arg_fail(5)) SWIG_fail;
32800 if (obj5) {
32801 {
32802 arg6 = wxString_in_helper(obj5);
32803 if (arg6 == NULL) SWIG_fail;
32804 temp6 = true;
32805 }
32806 }
32807 {
32808 PyThreadState* __tstate = wxPyBeginAllowThreads();
32809 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32810
32811 wxPyEndAllowThreads(__tstate);
32812 if (PyErr_Occurred()) SWIG_fail;
32813 }
32814 {
32815 resultobj = wxPyMake_wxObject(result, 0);
32816 }
32817 {
32818 if (temp4)
32819 delete arg4;
32820 }
32821 {
32822 if (temp6)
32823 delete arg6;
32824 }
32825 return resultobj;
32826 fail:
32827 {
32828 if (temp4)
32829 delete arg4;
32830 }
32831 {
32832 if (temp6)
32833 delete arg6;
32834 }
32835 return NULL;
32836 }
32837
32838
32839 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32840 PyObject *resultobj;
32841 wxMenu *arg1 = (wxMenu *) 0 ;
32842 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32843 wxMenuItem *result;
32844 PyObject * obj0 = 0 ;
32845 PyObject * obj1 = 0 ;
32846 char *kwnames[] = {
32847 (char *) "self",(char *) "item", NULL
32848 };
32849
32850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32852 if (SWIG_arg_fail(1)) SWIG_fail;
32853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32854 if (SWIG_arg_fail(2)) SWIG_fail;
32855 {
32856 PyThreadState* __tstate = wxPyBeginAllowThreads();
32857 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32858
32859 wxPyEndAllowThreads(__tstate);
32860 if (PyErr_Occurred()) SWIG_fail;
32861 }
32862 {
32863 resultobj = wxPyMake_wxObject(result, 0);
32864 }
32865 return resultobj;
32866 fail:
32867 return NULL;
32868 }
32869
32870
32871 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32872 PyObject *resultobj;
32873 wxMenu *arg1 = (wxMenu *) 0 ;
32874 int arg2 ;
32875 wxString *arg3 = 0 ;
32876 wxString const &arg4_defvalue = wxPyEmptyString ;
32877 wxString *arg4 = (wxString *) &arg4_defvalue ;
32878 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32879 wxMenuItem *result;
32880 bool temp3 = false ;
32881 bool temp4 = false ;
32882 PyObject * obj0 = 0 ;
32883 PyObject * obj1 = 0 ;
32884 PyObject * obj2 = 0 ;
32885 PyObject * obj3 = 0 ;
32886 PyObject * obj4 = 0 ;
32887 char *kwnames[] = {
32888 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32889 };
32890
32891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32893 if (SWIG_arg_fail(1)) SWIG_fail;
32894 {
32895 arg2 = (int)(SWIG_As_int(obj1));
32896 if (SWIG_arg_fail(2)) SWIG_fail;
32897 }
32898 {
32899 arg3 = wxString_in_helper(obj2);
32900 if (arg3 == NULL) SWIG_fail;
32901 temp3 = true;
32902 }
32903 if (obj3) {
32904 {
32905 arg4 = wxString_in_helper(obj3);
32906 if (arg4 == NULL) SWIG_fail;
32907 temp4 = true;
32908 }
32909 }
32910 if (obj4) {
32911 {
32912 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32913 if (SWIG_arg_fail(5)) SWIG_fail;
32914 }
32915 }
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32919
32920 wxPyEndAllowThreads(__tstate);
32921 if (PyErr_Occurred()) SWIG_fail;
32922 }
32923 {
32924 resultobj = wxPyMake_wxObject(result, 0);
32925 }
32926 {
32927 if (temp3)
32928 delete arg3;
32929 }
32930 {
32931 if (temp4)
32932 delete arg4;
32933 }
32934 return resultobj;
32935 fail:
32936 {
32937 if (temp3)
32938 delete arg3;
32939 }
32940 {
32941 if (temp4)
32942 delete arg4;
32943 }
32944 return NULL;
32945 }
32946
32947
32948 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32949 PyObject *resultobj;
32950 wxMenu *arg1 = (wxMenu *) 0 ;
32951 wxMenuItem *result;
32952 PyObject * obj0 = 0 ;
32953 char *kwnames[] = {
32954 (char *) "self", NULL
32955 };
32956
32957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32959 if (SWIG_arg_fail(1)) SWIG_fail;
32960 {
32961 PyThreadState* __tstate = wxPyBeginAllowThreads();
32962 result = (wxMenuItem *)(arg1)->PrependSeparator();
32963
32964 wxPyEndAllowThreads(__tstate);
32965 if (PyErr_Occurred()) SWIG_fail;
32966 }
32967 {
32968 resultobj = wxPyMake_wxObject(result, 0);
32969 }
32970 return resultobj;
32971 fail:
32972 return NULL;
32973 }
32974
32975
32976 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32977 PyObject *resultobj;
32978 wxMenu *arg1 = (wxMenu *) 0 ;
32979 int arg2 ;
32980 wxString *arg3 = 0 ;
32981 wxString const &arg4_defvalue = wxPyEmptyString ;
32982 wxString *arg4 = (wxString *) &arg4_defvalue ;
32983 wxMenuItem *result;
32984 bool temp3 = false ;
32985 bool temp4 = false ;
32986 PyObject * obj0 = 0 ;
32987 PyObject * obj1 = 0 ;
32988 PyObject * obj2 = 0 ;
32989 PyObject * obj3 = 0 ;
32990 char *kwnames[] = {
32991 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32992 };
32993
32994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32996 if (SWIG_arg_fail(1)) SWIG_fail;
32997 {
32998 arg2 = (int)(SWIG_As_int(obj1));
32999 if (SWIG_arg_fail(2)) SWIG_fail;
33000 }
33001 {
33002 arg3 = wxString_in_helper(obj2);
33003 if (arg3 == NULL) SWIG_fail;
33004 temp3 = true;
33005 }
33006 if (obj3) {
33007 {
33008 arg4 = wxString_in_helper(obj3);
33009 if (arg4 == NULL) SWIG_fail;
33010 temp4 = true;
33011 }
33012 }
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33016
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 {
33021 resultobj = wxPyMake_wxObject(result, 0);
33022 }
33023 {
33024 if (temp3)
33025 delete arg3;
33026 }
33027 {
33028 if (temp4)
33029 delete arg4;
33030 }
33031 return resultobj;
33032 fail:
33033 {
33034 if (temp3)
33035 delete arg3;
33036 }
33037 {
33038 if (temp4)
33039 delete arg4;
33040 }
33041 return NULL;
33042 }
33043
33044
33045 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33046 PyObject *resultobj;
33047 wxMenu *arg1 = (wxMenu *) 0 ;
33048 int arg2 ;
33049 wxString *arg3 = 0 ;
33050 wxString const &arg4_defvalue = wxPyEmptyString ;
33051 wxString *arg4 = (wxString *) &arg4_defvalue ;
33052 wxMenuItem *result;
33053 bool temp3 = false ;
33054 bool temp4 = false ;
33055 PyObject * obj0 = 0 ;
33056 PyObject * obj1 = 0 ;
33057 PyObject * obj2 = 0 ;
33058 PyObject * obj3 = 0 ;
33059 char *kwnames[] = {
33060 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33061 };
33062
33063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33065 if (SWIG_arg_fail(1)) SWIG_fail;
33066 {
33067 arg2 = (int)(SWIG_As_int(obj1));
33068 if (SWIG_arg_fail(2)) SWIG_fail;
33069 }
33070 {
33071 arg3 = wxString_in_helper(obj2);
33072 if (arg3 == NULL) SWIG_fail;
33073 temp3 = true;
33074 }
33075 if (obj3) {
33076 {
33077 arg4 = wxString_in_helper(obj3);
33078 if (arg4 == NULL) SWIG_fail;
33079 temp4 = true;
33080 }
33081 }
33082 {
33083 PyThreadState* __tstate = wxPyBeginAllowThreads();
33084 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33085
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 {
33090 resultobj = wxPyMake_wxObject(result, 0);
33091 }
33092 {
33093 if (temp3)
33094 delete arg3;
33095 }
33096 {
33097 if (temp4)
33098 delete arg4;
33099 }
33100 return resultobj;
33101 fail:
33102 {
33103 if (temp3)
33104 delete arg3;
33105 }
33106 {
33107 if (temp4)
33108 delete arg4;
33109 }
33110 return NULL;
33111 }
33112
33113
33114 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33115 PyObject *resultobj;
33116 wxMenu *arg1 = (wxMenu *) 0 ;
33117 int arg2 ;
33118 wxString *arg3 = 0 ;
33119 wxMenu *arg4 = (wxMenu *) 0 ;
33120 wxString const &arg5_defvalue = wxPyEmptyString ;
33121 wxString *arg5 = (wxString *) &arg5_defvalue ;
33122 wxMenuItem *result;
33123 bool temp3 = false ;
33124 bool temp5 = false ;
33125 PyObject * obj0 = 0 ;
33126 PyObject * obj1 = 0 ;
33127 PyObject * obj2 = 0 ;
33128 PyObject * obj3 = 0 ;
33129 PyObject * obj4 = 0 ;
33130 char *kwnames[] = {
33131 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33132 };
33133
33134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33136 if (SWIG_arg_fail(1)) SWIG_fail;
33137 {
33138 arg2 = (int)(SWIG_As_int(obj1));
33139 if (SWIG_arg_fail(2)) SWIG_fail;
33140 }
33141 {
33142 arg3 = wxString_in_helper(obj2);
33143 if (arg3 == NULL) SWIG_fail;
33144 temp3 = true;
33145 }
33146 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33147 if (SWIG_arg_fail(4)) SWIG_fail;
33148 if (obj4) {
33149 {
33150 arg5 = wxString_in_helper(obj4);
33151 if (arg5 == NULL) SWIG_fail;
33152 temp5 = true;
33153 }
33154 }
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33158
33159 wxPyEndAllowThreads(__tstate);
33160 if (PyErr_Occurred()) SWIG_fail;
33161 }
33162 {
33163 resultobj = wxPyMake_wxObject(result, 0);
33164 }
33165 {
33166 if (temp3)
33167 delete arg3;
33168 }
33169 {
33170 if (temp5)
33171 delete arg5;
33172 }
33173 return resultobj;
33174 fail:
33175 {
33176 if (temp3)
33177 delete arg3;
33178 }
33179 {
33180 if (temp5)
33181 delete arg5;
33182 }
33183 return NULL;
33184 }
33185
33186
33187 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj;
33189 wxMenu *arg1 = (wxMenu *) 0 ;
33190 int arg2 ;
33191 wxMenuItem *result;
33192 PyObject * obj0 = 0 ;
33193 PyObject * obj1 = 0 ;
33194 char *kwnames[] = {
33195 (char *) "self",(char *) "id", NULL
33196 };
33197
33198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33200 if (SWIG_arg_fail(1)) SWIG_fail;
33201 {
33202 arg2 = (int)(SWIG_As_int(obj1));
33203 if (SWIG_arg_fail(2)) SWIG_fail;
33204 }
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (wxMenuItem *)(arg1)->Remove(arg2);
33208
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 {
33213 resultobj = wxPyMake_wxObject(result, 0);
33214 }
33215 return resultobj;
33216 fail:
33217 return NULL;
33218 }
33219
33220
33221 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33222 PyObject *resultobj;
33223 wxMenu *arg1 = (wxMenu *) 0 ;
33224 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33225 wxMenuItem *result;
33226 PyObject * obj0 = 0 ;
33227 PyObject * obj1 = 0 ;
33228 char *kwnames[] = {
33229 (char *) "self",(char *) "item", NULL
33230 };
33231
33232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33234 if (SWIG_arg_fail(1)) SWIG_fail;
33235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33236 if (SWIG_arg_fail(2)) SWIG_fail;
33237 {
33238 PyThreadState* __tstate = wxPyBeginAllowThreads();
33239 result = (wxMenuItem *)(arg1)->Remove(arg2);
33240
33241 wxPyEndAllowThreads(__tstate);
33242 if (PyErr_Occurred()) SWIG_fail;
33243 }
33244 {
33245 resultobj = wxPyMake_wxObject(result, 0);
33246 }
33247 return resultobj;
33248 fail:
33249 return NULL;
33250 }
33251
33252
33253 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33254 PyObject *resultobj;
33255 wxMenu *arg1 = (wxMenu *) 0 ;
33256 int arg2 ;
33257 bool result;
33258 PyObject * obj0 = 0 ;
33259 PyObject * obj1 = 0 ;
33260 char *kwnames[] = {
33261 (char *) "self",(char *) "id", NULL
33262 };
33263
33264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33266 if (SWIG_arg_fail(1)) SWIG_fail;
33267 {
33268 arg2 = (int)(SWIG_As_int(obj1));
33269 if (SWIG_arg_fail(2)) SWIG_fail;
33270 }
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 result = (bool)(arg1)->Delete(arg2);
33274
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 {
33279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33280 }
33281 return resultobj;
33282 fail:
33283 return NULL;
33284 }
33285
33286
33287 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33288 PyObject *resultobj;
33289 wxMenu *arg1 = (wxMenu *) 0 ;
33290 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33291 bool result;
33292 PyObject * obj0 = 0 ;
33293 PyObject * obj1 = 0 ;
33294 char *kwnames[] = {
33295 (char *) "self",(char *) "item", NULL
33296 };
33297
33298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33300 if (SWIG_arg_fail(1)) SWIG_fail;
33301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33302 if (SWIG_arg_fail(2)) SWIG_fail;
33303 {
33304 PyThreadState* __tstate = wxPyBeginAllowThreads();
33305 result = (bool)(arg1)->Delete(arg2);
33306
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 {
33311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33312 }
33313 return resultobj;
33314 fail:
33315 return NULL;
33316 }
33317
33318
33319 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33320 PyObject *resultobj;
33321 wxMenu *arg1 = (wxMenu *) 0 ;
33322 PyObject * obj0 = 0 ;
33323 char *kwnames[] = {
33324 (char *) "self", NULL
33325 };
33326
33327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33329 if (SWIG_arg_fail(1)) SWIG_fail;
33330 {
33331 PyThreadState* __tstate = wxPyBeginAllowThreads();
33332 wxMenu_Destroy(arg1);
33333
33334 wxPyEndAllowThreads(__tstate);
33335 if (PyErr_Occurred()) SWIG_fail;
33336 }
33337 Py_INCREF(Py_None); resultobj = Py_None;
33338 return resultobj;
33339 fail:
33340 return NULL;
33341 }
33342
33343
33344 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33345 PyObject *resultobj;
33346 wxMenu *arg1 = (wxMenu *) 0 ;
33347 int arg2 ;
33348 bool result;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 char *kwnames[] = {
33352 (char *) "self",(char *) "id", NULL
33353 };
33354
33355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33357 if (SWIG_arg_fail(1)) SWIG_fail;
33358 {
33359 arg2 = (int)(SWIG_As_int(obj1));
33360 if (SWIG_arg_fail(2)) SWIG_fail;
33361 }
33362 {
33363 PyThreadState* __tstate = wxPyBeginAllowThreads();
33364 result = (bool)(arg1)->Destroy(arg2);
33365
33366 wxPyEndAllowThreads(__tstate);
33367 if (PyErr_Occurred()) SWIG_fail;
33368 }
33369 {
33370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33371 }
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj;
33380 wxMenu *arg1 = (wxMenu *) 0 ;
33381 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33382 bool result;
33383 PyObject * obj0 = 0 ;
33384 PyObject * obj1 = 0 ;
33385 char *kwnames[] = {
33386 (char *) "self",(char *) "item", NULL
33387 };
33388
33389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33391 if (SWIG_arg_fail(1)) SWIG_fail;
33392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33393 if (SWIG_arg_fail(2)) SWIG_fail;
33394 {
33395 PyThreadState* __tstate = wxPyBeginAllowThreads();
33396 result = (bool)(arg1)->Destroy(arg2);
33397
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 {
33402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33403 }
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33411 PyObject *resultobj;
33412 wxMenu *arg1 = (wxMenu *) 0 ;
33413 size_t result;
33414 PyObject * obj0 = 0 ;
33415 char *kwnames[] = {
33416 (char *) "self", NULL
33417 };
33418
33419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33421 if (SWIG_arg_fail(1)) SWIG_fail;
33422 {
33423 PyThreadState* __tstate = wxPyBeginAllowThreads();
33424 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33425
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 {
33430 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33431 }
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33439 PyObject *resultobj;
33440 wxMenu *arg1 = (wxMenu *) 0 ;
33441 PyObject *result;
33442 PyObject * obj0 = 0 ;
33443 char *kwnames[] = {
33444 (char *) "self", NULL
33445 };
33446
33447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33449 if (SWIG_arg_fail(1)) SWIG_fail;
33450 {
33451 PyThreadState* __tstate = wxPyBeginAllowThreads();
33452 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33453
33454 wxPyEndAllowThreads(__tstate);
33455 if (PyErr_Occurred()) SWIG_fail;
33456 }
33457 resultobj = result;
33458 return resultobj;
33459 fail:
33460 return NULL;
33461 }
33462
33463
33464 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33465 PyObject *resultobj;
33466 wxMenu *arg1 = (wxMenu *) 0 ;
33467 wxString *arg2 = 0 ;
33468 int result;
33469 bool temp2 = false ;
33470 PyObject * obj0 = 0 ;
33471 PyObject * obj1 = 0 ;
33472 char *kwnames[] = {
33473 (char *) "self",(char *) "item", NULL
33474 };
33475
33476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33478 if (SWIG_arg_fail(1)) SWIG_fail;
33479 {
33480 arg2 = wxString_in_helper(obj1);
33481 if (arg2 == NULL) SWIG_fail;
33482 temp2 = true;
33483 }
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33487
33488 wxPyEndAllowThreads(__tstate);
33489 if (PyErr_Occurred()) SWIG_fail;
33490 }
33491 {
33492 resultobj = SWIG_From_int((int)(result));
33493 }
33494 {
33495 if (temp2)
33496 delete arg2;
33497 }
33498 return resultobj;
33499 fail:
33500 {
33501 if (temp2)
33502 delete arg2;
33503 }
33504 return NULL;
33505 }
33506
33507
33508 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33509 PyObject *resultobj;
33510 wxMenu *arg1 = (wxMenu *) 0 ;
33511 int arg2 ;
33512 wxMenuItem *result;
33513 PyObject * obj0 = 0 ;
33514 PyObject * obj1 = 0 ;
33515 char *kwnames[] = {
33516 (char *) "self",(char *) "id", NULL
33517 };
33518
33519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33521 if (SWIG_arg_fail(1)) SWIG_fail;
33522 {
33523 arg2 = (int)(SWIG_As_int(obj1));
33524 if (SWIG_arg_fail(2)) SWIG_fail;
33525 }
33526 {
33527 PyThreadState* __tstate = wxPyBeginAllowThreads();
33528 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33529
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 {
33534 resultobj = wxPyMake_wxObject(result, 0);
33535 }
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33543 PyObject *resultobj;
33544 wxMenu *arg1 = (wxMenu *) 0 ;
33545 size_t arg2 ;
33546 wxMenuItem *result;
33547 PyObject * obj0 = 0 ;
33548 PyObject * obj1 = 0 ;
33549 char *kwnames[] = {
33550 (char *) "self",(char *) "position", NULL
33551 };
33552
33553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33555 if (SWIG_arg_fail(1)) SWIG_fail;
33556 {
33557 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33558 if (SWIG_arg_fail(2)) SWIG_fail;
33559 }
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33563
33564 wxPyEndAllowThreads(__tstate);
33565 if (PyErr_Occurred()) SWIG_fail;
33566 }
33567 {
33568 resultobj = wxPyMake_wxObject(result, 0);
33569 }
33570 return resultobj;
33571 fail:
33572 return NULL;
33573 }
33574
33575
33576 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33577 PyObject *resultobj;
33578 wxMenu *arg1 = (wxMenu *) 0 ;
33579 int arg2 ;
33580 bool arg3 ;
33581 PyObject * obj0 = 0 ;
33582 PyObject * obj1 = 0 ;
33583 PyObject * obj2 = 0 ;
33584 char *kwnames[] = {
33585 (char *) "self",(char *) "id",(char *) "enable", NULL
33586 };
33587
33588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33590 if (SWIG_arg_fail(1)) SWIG_fail;
33591 {
33592 arg2 = (int)(SWIG_As_int(obj1));
33593 if (SWIG_arg_fail(2)) SWIG_fail;
33594 }
33595 {
33596 arg3 = (bool)(SWIG_As_bool(obj2));
33597 if (SWIG_arg_fail(3)) SWIG_fail;
33598 }
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 (arg1)->Enable(arg2,arg3);
33602
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 Py_INCREF(Py_None); resultobj = Py_None;
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj;
33615 wxMenu *arg1 = (wxMenu *) 0 ;
33616 int arg2 ;
33617 bool result;
33618 PyObject * obj0 = 0 ;
33619 PyObject * obj1 = 0 ;
33620 char *kwnames[] = {
33621 (char *) "self",(char *) "id", NULL
33622 };
33623
33624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33626 if (SWIG_arg_fail(1)) SWIG_fail;
33627 {
33628 arg2 = (int)(SWIG_As_int(obj1));
33629 if (SWIG_arg_fail(2)) SWIG_fail;
33630 }
33631 {
33632 PyThreadState* __tstate = wxPyBeginAllowThreads();
33633 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33634
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 {
33639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33640 }
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33648 PyObject *resultobj;
33649 wxMenu *arg1 = (wxMenu *) 0 ;
33650 int arg2 ;
33651 bool arg3 ;
33652 PyObject * obj0 = 0 ;
33653 PyObject * obj1 = 0 ;
33654 PyObject * obj2 = 0 ;
33655 char *kwnames[] = {
33656 (char *) "self",(char *) "id",(char *) "check", NULL
33657 };
33658
33659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33661 if (SWIG_arg_fail(1)) SWIG_fail;
33662 {
33663 arg2 = (int)(SWIG_As_int(obj1));
33664 if (SWIG_arg_fail(2)) SWIG_fail;
33665 }
33666 {
33667 arg3 = (bool)(SWIG_As_bool(obj2));
33668 if (SWIG_arg_fail(3)) SWIG_fail;
33669 }
33670 {
33671 PyThreadState* __tstate = wxPyBeginAllowThreads();
33672 (arg1)->Check(arg2,arg3);
33673
33674 wxPyEndAllowThreads(__tstate);
33675 if (PyErr_Occurred()) SWIG_fail;
33676 }
33677 Py_INCREF(Py_None); resultobj = Py_None;
33678 return resultobj;
33679 fail:
33680 return NULL;
33681 }
33682
33683
33684 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33685 PyObject *resultobj;
33686 wxMenu *arg1 = (wxMenu *) 0 ;
33687 int arg2 ;
33688 bool result;
33689 PyObject * obj0 = 0 ;
33690 PyObject * obj1 = 0 ;
33691 char *kwnames[] = {
33692 (char *) "self",(char *) "id", NULL
33693 };
33694
33695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33697 if (SWIG_arg_fail(1)) SWIG_fail;
33698 {
33699 arg2 = (int)(SWIG_As_int(obj1));
33700 if (SWIG_arg_fail(2)) SWIG_fail;
33701 }
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33705
33706 wxPyEndAllowThreads(__tstate);
33707 if (PyErr_Occurred()) SWIG_fail;
33708 }
33709 {
33710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33711 }
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33719 PyObject *resultobj;
33720 wxMenu *arg1 = (wxMenu *) 0 ;
33721 int arg2 ;
33722 wxString *arg3 = 0 ;
33723 bool temp3 = false ;
33724 PyObject * obj0 = 0 ;
33725 PyObject * obj1 = 0 ;
33726 PyObject * obj2 = 0 ;
33727 char *kwnames[] = {
33728 (char *) "self",(char *) "id",(char *) "label", NULL
33729 };
33730
33731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33733 if (SWIG_arg_fail(1)) SWIG_fail;
33734 {
33735 arg2 = (int)(SWIG_As_int(obj1));
33736 if (SWIG_arg_fail(2)) SWIG_fail;
33737 }
33738 {
33739 arg3 = wxString_in_helper(obj2);
33740 if (arg3 == NULL) SWIG_fail;
33741 temp3 = true;
33742 }
33743 {
33744 PyThreadState* __tstate = wxPyBeginAllowThreads();
33745 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33746
33747 wxPyEndAllowThreads(__tstate);
33748 if (PyErr_Occurred()) SWIG_fail;
33749 }
33750 Py_INCREF(Py_None); resultobj = Py_None;
33751 {
33752 if (temp3)
33753 delete arg3;
33754 }
33755 return resultobj;
33756 fail:
33757 {
33758 if (temp3)
33759 delete arg3;
33760 }
33761 return NULL;
33762 }
33763
33764
33765 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33766 PyObject *resultobj;
33767 wxMenu *arg1 = (wxMenu *) 0 ;
33768 int arg2 ;
33769 wxString result;
33770 PyObject * obj0 = 0 ;
33771 PyObject * obj1 = 0 ;
33772 char *kwnames[] = {
33773 (char *) "self",(char *) "id", NULL
33774 };
33775
33776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33778 if (SWIG_arg_fail(1)) SWIG_fail;
33779 {
33780 arg2 = (int)(SWIG_As_int(obj1));
33781 if (SWIG_arg_fail(2)) SWIG_fail;
33782 }
33783 {
33784 PyThreadState* __tstate = wxPyBeginAllowThreads();
33785 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33786
33787 wxPyEndAllowThreads(__tstate);
33788 if (PyErr_Occurred()) SWIG_fail;
33789 }
33790 {
33791 #if wxUSE_UNICODE
33792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33793 #else
33794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33795 #endif
33796 }
33797 return resultobj;
33798 fail:
33799 return NULL;
33800 }
33801
33802
33803 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33804 PyObject *resultobj;
33805 wxMenu *arg1 = (wxMenu *) 0 ;
33806 int arg2 ;
33807 wxString *arg3 = 0 ;
33808 bool temp3 = false ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 PyObject * obj2 = 0 ;
33812 char *kwnames[] = {
33813 (char *) "self",(char *) "id",(char *) "helpString", NULL
33814 };
33815
33816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33818 if (SWIG_arg_fail(1)) SWIG_fail;
33819 {
33820 arg2 = (int)(SWIG_As_int(obj1));
33821 if (SWIG_arg_fail(2)) SWIG_fail;
33822 }
33823 {
33824 arg3 = wxString_in_helper(obj2);
33825 if (arg3 == NULL) SWIG_fail;
33826 temp3 = true;
33827 }
33828 {
33829 PyThreadState* __tstate = wxPyBeginAllowThreads();
33830 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33831
33832 wxPyEndAllowThreads(__tstate);
33833 if (PyErr_Occurred()) SWIG_fail;
33834 }
33835 Py_INCREF(Py_None); resultobj = Py_None;
33836 {
33837 if (temp3)
33838 delete arg3;
33839 }
33840 return resultobj;
33841 fail:
33842 {
33843 if (temp3)
33844 delete arg3;
33845 }
33846 return NULL;
33847 }
33848
33849
33850 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33851 PyObject *resultobj;
33852 wxMenu *arg1 = (wxMenu *) 0 ;
33853 int arg2 ;
33854 wxString result;
33855 PyObject * obj0 = 0 ;
33856 PyObject * obj1 = 0 ;
33857 char *kwnames[] = {
33858 (char *) "self",(char *) "id", NULL
33859 };
33860
33861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33863 if (SWIG_arg_fail(1)) SWIG_fail;
33864 {
33865 arg2 = (int)(SWIG_As_int(obj1));
33866 if (SWIG_arg_fail(2)) SWIG_fail;
33867 }
33868 {
33869 PyThreadState* __tstate = wxPyBeginAllowThreads();
33870 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33871
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 {
33876 #if wxUSE_UNICODE
33877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33878 #else
33879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33880 #endif
33881 }
33882 return resultobj;
33883 fail:
33884 return NULL;
33885 }
33886
33887
33888 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33889 PyObject *resultobj;
33890 wxMenu *arg1 = (wxMenu *) 0 ;
33891 wxString *arg2 = 0 ;
33892 bool temp2 = false ;
33893 PyObject * obj0 = 0 ;
33894 PyObject * obj1 = 0 ;
33895 char *kwnames[] = {
33896 (char *) "self",(char *) "title", NULL
33897 };
33898
33899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33901 if (SWIG_arg_fail(1)) SWIG_fail;
33902 {
33903 arg2 = wxString_in_helper(obj1);
33904 if (arg2 == NULL) SWIG_fail;
33905 temp2 = true;
33906 }
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 (arg1)->SetTitle((wxString const &)*arg2);
33910
33911 wxPyEndAllowThreads(__tstate);
33912 if (PyErr_Occurred()) SWIG_fail;
33913 }
33914 Py_INCREF(Py_None); resultobj = Py_None;
33915 {
33916 if (temp2)
33917 delete arg2;
33918 }
33919 return resultobj;
33920 fail:
33921 {
33922 if (temp2)
33923 delete arg2;
33924 }
33925 return NULL;
33926 }
33927
33928
33929 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj;
33931 wxMenu *arg1 = (wxMenu *) 0 ;
33932 wxString result;
33933 PyObject * obj0 = 0 ;
33934 char *kwnames[] = {
33935 (char *) "self", NULL
33936 };
33937
33938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33940 if (SWIG_arg_fail(1)) SWIG_fail;
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 result = ((wxMenu const *)arg1)->GetTitle();
33944
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 {
33949 #if wxUSE_UNICODE
33950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33951 #else
33952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33953 #endif
33954 }
33955 return resultobj;
33956 fail:
33957 return NULL;
33958 }
33959
33960
33961 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33962 PyObject *resultobj;
33963 wxMenu *arg1 = (wxMenu *) 0 ;
33964 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33965 PyObject * obj0 = 0 ;
33966 PyObject * obj1 = 0 ;
33967 char *kwnames[] = {
33968 (char *) "self",(char *) "handler", NULL
33969 };
33970
33971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33973 if (SWIG_arg_fail(1)) SWIG_fail;
33974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33975 if (SWIG_arg_fail(2)) SWIG_fail;
33976 {
33977 PyThreadState* __tstate = wxPyBeginAllowThreads();
33978 (arg1)->SetEventHandler(arg2);
33979
33980 wxPyEndAllowThreads(__tstate);
33981 if (PyErr_Occurred()) SWIG_fail;
33982 }
33983 Py_INCREF(Py_None); resultobj = Py_None;
33984 return resultobj;
33985 fail:
33986 return NULL;
33987 }
33988
33989
33990 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33991 PyObject *resultobj;
33992 wxMenu *arg1 = (wxMenu *) 0 ;
33993 wxEvtHandler *result;
33994 PyObject * obj0 = 0 ;
33995 char *kwnames[] = {
33996 (char *) "self", NULL
33997 };
33998
33999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34001 if (SWIG_arg_fail(1)) SWIG_fail;
34002 {
34003 PyThreadState* __tstate = wxPyBeginAllowThreads();
34004 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34005
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 {
34010 resultobj = wxPyMake_wxObject(result, 0);
34011 }
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34019 PyObject *resultobj;
34020 wxMenu *arg1 = (wxMenu *) 0 ;
34021 wxWindow *arg2 = (wxWindow *) 0 ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char *kwnames[] = {
34025 (char *) "self",(char *) "win", NULL
34026 };
34027
34028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34030 if (SWIG_arg_fail(1)) SWIG_fail;
34031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34032 if (SWIG_arg_fail(2)) SWIG_fail;
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 (arg1)->SetInvokingWindow(arg2);
34036
34037 wxPyEndAllowThreads(__tstate);
34038 if (PyErr_Occurred()) SWIG_fail;
34039 }
34040 Py_INCREF(Py_None); resultobj = Py_None;
34041 return resultobj;
34042 fail:
34043 return NULL;
34044 }
34045
34046
34047 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34048 PyObject *resultobj;
34049 wxMenu *arg1 = (wxMenu *) 0 ;
34050 wxWindow *result;
34051 PyObject * obj0 = 0 ;
34052 char *kwnames[] = {
34053 (char *) "self", NULL
34054 };
34055
34056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34058 if (SWIG_arg_fail(1)) SWIG_fail;
34059 {
34060 PyThreadState* __tstate = wxPyBeginAllowThreads();
34061 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34062
34063 wxPyEndAllowThreads(__tstate);
34064 if (PyErr_Occurred()) SWIG_fail;
34065 }
34066 {
34067 resultobj = wxPyMake_wxObject(result, 0);
34068 }
34069 return resultobj;
34070 fail:
34071 return NULL;
34072 }
34073
34074
34075 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34076 PyObject *resultobj;
34077 wxMenu *arg1 = (wxMenu *) 0 ;
34078 long result;
34079 PyObject * obj0 = 0 ;
34080 char *kwnames[] = {
34081 (char *) "self", NULL
34082 };
34083
34084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34086 if (SWIG_arg_fail(1)) SWIG_fail;
34087 {
34088 PyThreadState* __tstate = wxPyBeginAllowThreads();
34089 result = (long)((wxMenu const *)arg1)->GetStyle();
34090
34091 wxPyEndAllowThreads(__tstate);
34092 if (PyErr_Occurred()) SWIG_fail;
34093 }
34094 {
34095 resultobj = SWIG_From_long((long)(result));
34096 }
34097 return resultobj;
34098 fail:
34099 return NULL;
34100 }
34101
34102
34103 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34104 PyObject *resultobj;
34105 wxMenu *arg1 = (wxMenu *) 0 ;
34106 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 char *kwnames[] = {
34110 (char *) "self",(char *) "source", NULL
34111 };
34112
34113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34115 if (SWIG_arg_fail(1)) SWIG_fail;
34116 if (obj1) {
34117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34118 if (SWIG_arg_fail(2)) SWIG_fail;
34119 }
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 (arg1)->UpdateUI(arg2);
34123
34124 wxPyEndAllowThreads(__tstate);
34125 if (PyErr_Occurred()) SWIG_fail;
34126 }
34127 Py_INCREF(Py_None); resultobj = Py_None;
34128 return resultobj;
34129 fail:
34130 return NULL;
34131 }
34132
34133
34134 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34135 PyObject *resultobj;
34136 wxMenu *arg1 = (wxMenu *) 0 ;
34137 wxMenuBar *result;
34138 PyObject * obj0 = 0 ;
34139 char *kwnames[] = {
34140 (char *) "self", NULL
34141 };
34142
34143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34145 if (SWIG_arg_fail(1)) SWIG_fail;
34146 {
34147 PyThreadState* __tstate = wxPyBeginAllowThreads();
34148 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34149
34150 wxPyEndAllowThreads(__tstate);
34151 if (PyErr_Occurred()) SWIG_fail;
34152 }
34153 {
34154 resultobj = wxPyMake_wxObject(result, 0);
34155 }
34156 return resultobj;
34157 fail:
34158 return NULL;
34159 }
34160
34161
34162 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34163 PyObject *resultobj;
34164 wxMenu *arg1 = (wxMenu *) 0 ;
34165 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 char *kwnames[] = {
34169 (char *) "self",(char *) "menubar", NULL
34170 };
34171
34172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34174 if (SWIG_arg_fail(1)) SWIG_fail;
34175 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34176 if (SWIG_arg_fail(2)) SWIG_fail;
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 (arg1)->Attach(arg2);
34180
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 Py_INCREF(Py_None); resultobj = Py_None;
34185 return resultobj;
34186 fail:
34187 return NULL;
34188 }
34189
34190
34191 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34192 PyObject *resultobj;
34193 wxMenu *arg1 = (wxMenu *) 0 ;
34194 PyObject * obj0 = 0 ;
34195 char *kwnames[] = {
34196 (char *) "self", NULL
34197 };
34198
34199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34201 if (SWIG_arg_fail(1)) SWIG_fail;
34202 {
34203 PyThreadState* __tstate = wxPyBeginAllowThreads();
34204 (arg1)->Detach();
34205
34206 wxPyEndAllowThreads(__tstate);
34207 if (PyErr_Occurred()) SWIG_fail;
34208 }
34209 Py_INCREF(Py_None); resultobj = Py_None;
34210 return resultobj;
34211 fail:
34212 return NULL;
34213 }
34214
34215
34216 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34217 PyObject *resultobj;
34218 wxMenu *arg1 = (wxMenu *) 0 ;
34219 bool result;
34220 PyObject * obj0 = 0 ;
34221 char *kwnames[] = {
34222 (char *) "self", NULL
34223 };
34224
34225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34227 if (SWIG_arg_fail(1)) SWIG_fail;
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 result = (bool)((wxMenu const *)arg1)->IsAttached();
34231
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 {
34236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34237 }
34238 return resultobj;
34239 fail:
34240 return NULL;
34241 }
34242
34243
34244 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34245 PyObject *resultobj;
34246 wxMenu *arg1 = (wxMenu *) 0 ;
34247 wxMenu *arg2 = (wxMenu *) 0 ;
34248 PyObject * obj0 = 0 ;
34249 PyObject * obj1 = 0 ;
34250 char *kwnames[] = {
34251 (char *) "self",(char *) "parent", NULL
34252 };
34253
34254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34256 if (SWIG_arg_fail(1)) SWIG_fail;
34257 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34258 if (SWIG_arg_fail(2)) SWIG_fail;
34259 {
34260 PyThreadState* __tstate = wxPyBeginAllowThreads();
34261 (arg1)->SetParent(arg2);
34262
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 Py_INCREF(Py_None); resultobj = Py_None;
34267 return resultobj;
34268 fail:
34269 return NULL;
34270 }
34271
34272
34273 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34274 PyObject *resultobj;
34275 wxMenu *arg1 = (wxMenu *) 0 ;
34276 wxMenu *result;
34277 PyObject * obj0 = 0 ;
34278 char *kwnames[] = {
34279 (char *) "self", NULL
34280 };
34281
34282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34284 if (SWIG_arg_fail(1)) SWIG_fail;
34285 {
34286 PyThreadState* __tstate = wxPyBeginAllowThreads();
34287 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34288
34289 wxPyEndAllowThreads(__tstate);
34290 if (PyErr_Occurred()) SWIG_fail;
34291 }
34292 {
34293 resultobj = wxPyMake_wxObject(result, 0);
34294 }
34295 return resultobj;
34296 fail:
34297 return NULL;
34298 }
34299
34300
34301 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34302 PyObject *obj;
34303 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34304 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34305 Py_INCREF(obj);
34306 return Py_BuildValue((char *)"");
34307 }
34308 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34309 PyObject *resultobj;
34310 long arg1 = (long) 0 ;
34311 wxMenuBar *result;
34312 PyObject * obj0 = 0 ;
34313 char *kwnames[] = {
34314 (char *) "style", NULL
34315 };
34316
34317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34318 if (obj0) {
34319 {
34320 arg1 = (long)(SWIG_As_long(obj0));
34321 if (SWIG_arg_fail(1)) SWIG_fail;
34322 }
34323 }
34324 {
34325 if (!wxPyCheckForApp()) SWIG_fail;
34326 PyThreadState* __tstate = wxPyBeginAllowThreads();
34327 result = (wxMenuBar *)new wxMenuBar(arg1);
34328
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34340 PyObject *resultobj;
34341 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34342 wxMenu *arg2 = (wxMenu *) 0 ;
34343 wxString *arg3 = 0 ;
34344 bool result;
34345 bool temp3 = false ;
34346 PyObject * obj0 = 0 ;
34347 PyObject * obj1 = 0 ;
34348 PyObject * obj2 = 0 ;
34349 char *kwnames[] = {
34350 (char *) "self",(char *) "menu",(char *) "title", NULL
34351 };
34352
34353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34355 if (SWIG_arg_fail(1)) SWIG_fail;
34356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34357 if (SWIG_arg_fail(2)) SWIG_fail;
34358 {
34359 arg3 = wxString_in_helper(obj2);
34360 if (arg3 == NULL) SWIG_fail;
34361 temp3 = true;
34362 }
34363 {
34364 PyThreadState* __tstate = wxPyBeginAllowThreads();
34365 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34366
34367 wxPyEndAllowThreads(__tstate);
34368 if (PyErr_Occurred()) SWIG_fail;
34369 }
34370 {
34371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34372 }
34373 {
34374 if (temp3)
34375 delete arg3;
34376 }
34377 return resultobj;
34378 fail:
34379 {
34380 if (temp3)
34381 delete arg3;
34382 }
34383 return NULL;
34384 }
34385
34386
34387 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34388 PyObject *resultobj;
34389 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34390 size_t arg2 ;
34391 wxMenu *arg3 = (wxMenu *) 0 ;
34392 wxString *arg4 = 0 ;
34393 bool result;
34394 bool temp4 = false ;
34395 PyObject * obj0 = 0 ;
34396 PyObject * obj1 = 0 ;
34397 PyObject * obj2 = 0 ;
34398 PyObject * obj3 = 0 ;
34399 char *kwnames[] = {
34400 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34401 };
34402
34403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34405 if (SWIG_arg_fail(1)) SWIG_fail;
34406 {
34407 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34408 if (SWIG_arg_fail(2)) SWIG_fail;
34409 }
34410 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34411 if (SWIG_arg_fail(3)) SWIG_fail;
34412 {
34413 arg4 = wxString_in_helper(obj3);
34414 if (arg4 == NULL) SWIG_fail;
34415 temp4 = true;
34416 }
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34420
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 {
34425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34426 }
34427 {
34428 if (temp4)
34429 delete arg4;
34430 }
34431 return resultobj;
34432 fail:
34433 {
34434 if (temp4)
34435 delete arg4;
34436 }
34437 return NULL;
34438 }
34439
34440
34441 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34442 PyObject *resultobj;
34443 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34444 size_t result;
34445 PyObject * obj0 = 0 ;
34446 char *kwnames[] = {
34447 (char *) "self", NULL
34448 };
34449
34450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34452 if (SWIG_arg_fail(1)) SWIG_fail;
34453 {
34454 PyThreadState* __tstate = wxPyBeginAllowThreads();
34455 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34456
34457 wxPyEndAllowThreads(__tstate);
34458 if (PyErr_Occurred()) SWIG_fail;
34459 }
34460 {
34461 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34462 }
34463 return resultobj;
34464 fail:
34465 return NULL;
34466 }
34467
34468
34469 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34470 PyObject *resultobj;
34471 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34472 size_t arg2 ;
34473 wxMenu *result;
34474 PyObject * obj0 = 0 ;
34475 PyObject * obj1 = 0 ;
34476 char *kwnames[] = {
34477 (char *) "self",(char *) "pos", NULL
34478 };
34479
34480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34482 if (SWIG_arg_fail(1)) SWIG_fail;
34483 {
34484 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34485 if (SWIG_arg_fail(2)) SWIG_fail;
34486 }
34487 {
34488 PyThreadState* __tstate = wxPyBeginAllowThreads();
34489 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34490
34491 wxPyEndAllowThreads(__tstate);
34492 if (PyErr_Occurred()) SWIG_fail;
34493 }
34494 {
34495 resultobj = wxPyMake_wxObject(result, 0);
34496 }
34497 return resultobj;
34498 fail:
34499 return NULL;
34500 }
34501
34502
34503 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34504 PyObject *resultobj;
34505 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34506 size_t arg2 ;
34507 wxMenu *arg3 = (wxMenu *) 0 ;
34508 wxString *arg4 = 0 ;
34509 wxMenu *result;
34510 bool temp4 = false ;
34511 PyObject * obj0 = 0 ;
34512 PyObject * obj1 = 0 ;
34513 PyObject * obj2 = 0 ;
34514 PyObject * obj3 = 0 ;
34515 char *kwnames[] = {
34516 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34517 };
34518
34519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34521 if (SWIG_arg_fail(1)) SWIG_fail;
34522 {
34523 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34524 if (SWIG_arg_fail(2)) SWIG_fail;
34525 }
34526 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34527 if (SWIG_arg_fail(3)) SWIG_fail;
34528 {
34529 arg4 = wxString_in_helper(obj3);
34530 if (arg4 == NULL) SWIG_fail;
34531 temp4 = true;
34532 }
34533 {
34534 PyThreadState* __tstate = wxPyBeginAllowThreads();
34535 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34536
34537 wxPyEndAllowThreads(__tstate);
34538 if (PyErr_Occurred()) SWIG_fail;
34539 }
34540 {
34541 resultobj = wxPyMake_wxObject(result, 0);
34542 }
34543 {
34544 if (temp4)
34545 delete arg4;
34546 }
34547 return resultobj;
34548 fail:
34549 {
34550 if (temp4)
34551 delete arg4;
34552 }
34553 return NULL;
34554 }
34555
34556
34557 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34558 PyObject *resultobj;
34559 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34560 size_t arg2 ;
34561 wxMenu *result;
34562 PyObject * obj0 = 0 ;
34563 PyObject * obj1 = 0 ;
34564 char *kwnames[] = {
34565 (char *) "self",(char *) "pos", NULL
34566 };
34567
34568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34570 if (SWIG_arg_fail(1)) SWIG_fail;
34571 {
34572 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34573 if (SWIG_arg_fail(2)) SWIG_fail;
34574 }
34575 {
34576 PyThreadState* __tstate = wxPyBeginAllowThreads();
34577 result = (wxMenu *)(arg1)->Remove(arg2);
34578
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 {
34583 resultobj = wxPyMake_wxObject(result, 0);
34584 }
34585 return resultobj;
34586 fail:
34587 return NULL;
34588 }
34589
34590
34591 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34592 PyObject *resultobj;
34593 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34594 size_t arg2 ;
34595 bool arg3 ;
34596 PyObject * obj0 = 0 ;
34597 PyObject * obj1 = 0 ;
34598 PyObject * obj2 = 0 ;
34599 char *kwnames[] = {
34600 (char *) "self",(char *) "pos",(char *) "enable", NULL
34601 };
34602
34603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34605 if (SWIG_arg_fail(1)) SWIG_fail;
34606 {
34607 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34608 if (SWIG_arg_fail(2)) SWIG_fail;
34609 }
34610 {
34611 arg3 = (bool)(SWIG_As_bool(obj2));
34612 if (SWIG_arg_fail(3)) SWIG_fail;
34613 }
34614 {
34615 PyThreadState* __tstate = wxPyBeginAllowThreads();
34616 (arg1)->EnableTop(arg2,arg3);
34617
34618 wxPyEndAllowThreads(__tstate);
34619 if (PyErr_Occurred()) SWIG_fail;
34620 }
34621 Py_INCREF(Py_None); resultobj = Py_None;
34622 return resultobj;
34623 fail:
34624 return NULL;
34625 }
34626
34627
34628 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34629 PyObject *resultobj;
34630 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34631 size_t arg2 ;
34632 bool result;
34633 PyObject * obj0 = 0 ;
34634 PyObject * obj1 = 0 ;
34635 char *kwnames[] = {
34636 (char *) "self",(char *) "pos", NULL
34637 };
34638
34639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34641 if (SWIG_arg_fail(1)) SWIG_fail;
34642 {
34643 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34644 if (SWIG_arg_fail(2)) SWIG_fail;
34645 }
34646 {
34647 PyThreadState* __tstate = wxPyBeginAllowThreads();
34648 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34649
34650 wxPyEndAllowThreads(__tstate);
34651 if (PyErr_Occurred()) SWIG_fail;
34652 }
34653 {
34654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34655 }
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34663 PyObject *resultobj;
34664 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34665 size_t arg2 ;
34666 wxString *arg3 = 0 ;
34667 bool temp3 = false ;
34668 PyObject * obj0 = 0 ;
34669 PyObject * obj1 = 0 ;
34670 PyObject * obj2 = 0 ;
34671 char *kwnames[] = {
34672 (char *) "self",(char *) "pos",(char *) "label", NULL
34673 };
34674
34675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34677 if (SWIG_arg_fail(1)) SWIG_fail;
34678 {
34679 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34680 if (SWIG_arg_fail(2)) SWIG_fail;
34681 }
34682 {
34683 arg3 = wxString_in_helper(obj2);
34684 if (arg3 == NULL) SWIG_fail;
34685 temp3 = true;
34686 }
34687 {
34688 PyThreadState* __tstate = wxPyBeginAllowThreads();
34689 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34690
34691 wxPyEndAllowThreads(__tstate);
34692 if (PyErr_Occurred()) SWIG_fail;
34693 }
34694 Py_INCREF(Py_None); resultobj = Py_None;
34695 {
34696 if (temp3)
34697 delete arg3;
34698 }
34699 return resultobj;
34700 fail:
34701 {
34702 if (temp3)
34703 delete arg3;
34704 }
34705 return NULL;
34706 }
34707
34708
34709 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34710 PyObject *resultobj;
34711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34712 size_t arg2 ;
34713 wxString result;
34714 PyObject * obj0 = 0 ;
34715 PyObject * obj1 = 0 ;
34716 char *kwnames[] = {
34717 (char *) "self",(char *) "pos", NULL
34718 };
34719
34720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34722 if (SWIG_arg_fail(1)) SWIG_fail;
34723 {
34724 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34725 if (SWIG_arg_fail(2)) SWIG_fail;
34726 }
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34730
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 {
34735 #if wxUSE_UNICODE
34736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34737 #else
34738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34739 #endif
34740 }
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj;
34749 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34750 wxString *arg2 = 0 ;
34751 wxString *arg3 = 0 ;
34752 int result;
34753 bool temp2 = false ;
34754 bool temp3 = false ;
34755 PyObject * obj0 = 0 ;
34756 PyObject * obj1 = 0 ;
34757 PyObject * obj2 = 0 ;
34758 char *kwnames[] = {
34759 (char *) "self",(char *) "menu",(char *) "item", NULL
34760 };
34761
34762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34764 if (SWIG_arg_fail(1)) SWIG_fail;
34765 {
34766 arg2 = wxString_in_helper(obj1);
34767 if (arg2 == NULL) SWIG_fail;
34768 temp2 = true;
34769 }
34770 {
34771 arg3 = wxString_in_helper(obj2);
34772 if (arg3 == NULL) SWIG_fail;
34773 temp3 = true;
34774 }
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34778
34779 wxPyEndAllowThreads(__tstate);
34780 if (PyErr_Occurred()) SWIG_fail;
34781 }
34782 {
34783 resultobj = SWIG_From_int((int)(result));
34784 }
34785 {
34786 if (temp2)
34787 delete arg2;
34788 }
34789 {
34790 if (temp3)
34791 delete arg3;
34792 }
34793 return resultobj;
34794 fail:
34795 {
34796 if (temp2)
34797 delete arg2;
34798 }
34799 {
34800 if (temp3)
34801 delete arg3;
34802 }
34803 return NULL;
34804 }
34805
34806
34807 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34808 PyObject *resultobj;
34809 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34810 int arg2 ;
34811 wxMenuItem *result;
34812 PyObject * obj0 = 0 ;
34813 PyObject * obj1 = 0 ;
34814 char *kwnames[] = {
34815 (char *) "self",(char *) "id", NULL
34816 };
34817
34818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34820 if (SWIG_arg_fail(1)) SWIG_fail;
34821 {
34822 arg2 = (int)(SWIG_As_int(obj1));
34823 if (SWIG_arg_fail(2)) SWIG_fail;
34824 }
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34828
34829 wxPyEndAllowThreads(__tstate);
34830 if (PyErr_Occurred()) SWIG_fail;
34831 }
34832 {
34833 resultobj = wxPyMake_wxObject(result, 0);
34834 }
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34842 PyObject *resultobj;
34843 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34844 wxString *arg2 = 0 ;
34845 int result;
34846 bool temp2 = false ;
34847 PyObject * obj0 = 0 ;
34848 PyObject * obj1 = 0 ;
34849 char *kwnames[] = {
34850 (char *) "self",(char *) "title", NULL
34851 };
34852
34853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34855 if (SWIG_arg_fail(1)) SWIG_fail;
34856 {
34857 arg2 = wxString_in_helper(obj1);
34858 if (arg2 == NULL) SWIG_fail;
34859 temp2 = true;
34860 }
34861 {
34862 PyThreadState* __tstate = wxPyBeginAllowThreads();
34863 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34864
34865 wxPyEndAllowThreads(__tstate);
34866 if (PyErr_Occurred()) SWIG_fail;
34867 }
34868 {
34869 resultobj = SWIG_From_int((int)(result));
34870 }
34871 {
34872 if (temp2)
34873 delete arg2;
34874 }
34875 return resultobj;
34876 fail:
34877 {
34878 if (temp2)
34879 delete arg2;
34880 }
34881 return NULL;
34882 }
34883
34884
34885 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34886 PyObject *resultobj;
34887 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34888 int arg2 ;
34889 bool arg3 ;
34890 PyObject * obj0 = 0 ;
34891 PyObject * obj1 = 0 ;
34892 PyObject * obj2 = 0 ;
34893 char *kwnames[] = {
34894 (char *) "self",(char *) "id",(char *) "enable", NULL
34895 };
34896
34897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34899 if (SWIG_arg_fail(1)) SWIG_fail;
34900 {
34901 arg2 = (int)(SWIG_As_int(obj1));
34902 if (SWIG_arg_fail(2)) SWIG_fail;
34903 }
34904 {
34905 arg3 = (bool)(SWIG_As_bool(obj2));
34906 if (SWIG_arg_fail(3)) SWIG_fail;
34907 }
34908 {
34909 PyThreadState* __tstate = wxPyBeginAllowThreads();
34910 (arg1)->Enable(arg2,arg3);
34911
34912 wxPyEndAllowThreads(__tstate);
34913 if (PyErr_Occurred()) SWIG_fail;
34914 }
34915 Py_INCREF(Py_None); resultobj = Py_None;
34916 return resultobj;
34917 fail:
34918 return NULL;
34919 }
34920
34921
34922 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34923 PyObject *resultobj;
34924 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34925 int arg2 ;
34926 bool arg3 ;
34927 PyObject * obj0 = 0 ;
34928 PyObject * obj1 = 0 ;
34929 PyObject * obj2 = 0 ;
34930 char *kwnames[] = {
34931 (char *) "self",(char *) "id",(char *) "check", NULL
34932 };
34933
34934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34936 if (SWIG_arg_fail(1)) SWIG_fail;
34937 {
34938 arg2 = (int)(SWIG_As_int(obj1));
34939 if (SWIG_arg_fail(2)) SWIG_fail;
34940 }
34941 {
34942 arg3 = (bool)(SWIG_As_bool(obj2));
34943 if (SWIG_arg_fail(3)) SWIG_fail;
34944 }
34945 {
34946 PyThreadState* __tstate = wxPyBeginAllowThreads();
34947 (arg1)->Check(arg2,arg3);
34948
34949 wxPyEndAllowThreads(__tstate);
34950 if (PyErr_Occurred()) SWIG_fail;
34951 }
34952 Py_INCREF(Py_None); resultobj = Py_None;
34953 return resultobj;
34954 fail:
34955 return NULL;
34956 }
34957
34958
34959 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34960 PyObject *resultobj;
34961 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34962 int arg2 ;
34963 bool result;
34964 PyObject * obj0 = 0 ;
34965 PyObject * obj1 = 0 ;
34966 char *kwnames[] = {
34967 (char *) "self",(char *) "id", NULL
34968 };
34969
34970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34972 if (SWIG_arg_fail(1)) SWIG_fail;
34973 {
34974 arg2 = (int)(SWIG_As_int(obj1));
34975 if (SWIG_arg_fail(2)) SWIG_fail;
34976 }
34977 {
34978 PyThreadState* __tstate = wxPyBeginAllowThreads();
34979 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34980
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 {
34985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34986 }
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34994 PyObject *resultobj;
34995 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34996 int arg2 ;
34997 bool result;
34998 PyObject * obj0 = 0 ;
34999 PyObject * obj1 = 0 ;
35000 char *kwnames[] = {
35001 (char *) "self",(char *) "id", NULL
35002 };
35003
35004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35006 if (SWIG_arg_fail(1)) SWIG_fail;
35007 {
35008 arg2 = (int)(SWIG_As_int(obj1));
35009 if (SWIG_arg_fail(2)) SWIG_fail;
35010 }
35011 {
35012 PyThreadState* __tstate = wxPyBeginAllowThreads();
35013 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35014
35015 wxPyEndAllowThreads(__tstate);
35016 if (PyErr_Occurred()) SWIG_fail;
35017 }
35018 {
35019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35020 }
35021 return resultobj;
35022 fail:
35023 return NULL;
35024 }
35025
35026
35027 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35028 PyObject *resultobj;
35029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35030 int arg2 ;
35031 wxString *arg3 = 0 ;
35032 bool temp3 = false ;
35033 PyObject * obj0 = 0 ;
35034 PyObject * obj1 = 0 ;
35035 PyObject * obj2 = 0 ;
35036 char *kwnames[] = {
35037 (char *) "self",(char *) "id",(char *) "label", NULL
35038 };
35039
35040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35042 if (SWIG_arg_fail(1)) SWIG_fail;
35043 {
35044 arg2 = (int)(SWIG_As_int(obj1));
35045 if (SWIG_arg_fail(2)) SWIG_fail;
35046 }
35047 {
35048 arg3 = wxString_in_helper(obj2);
35049 if (arg3 == NULL) SWIG_fail;
35050 temp3 = true;
35051 }
35052 {
35053 PyThreadState* __tstate = wxPyBeginAllowThreads();
35054 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35055
35056 wxPyEndAllowThreads(__tstate);
35057 if (PyErr_Occurred()) SWIG_fail;
35058 }
35059 Py_INCREF(Py_None); resultobj = Py_None;
35060 {
35061 if (temp3)
35062 delete arg3;
35063 }
35064 return resultobj;
35065 fail:
35066 {
35067 if (temp3)
35068 delete arg3;
35069 }
35070 return NULL;
35071 }
35072
35073
35074 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35075 PyObject *resultobj;
35076 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35077 int arg2 ;
35078 wxString result;
35079 PyObject * obj0 = 0 ;
35080 PyObject * obj1 = 0 ;
35081 char *kwnames[] = {
35082 (char *) "self",(char *) "id", NULL
35083 };
35084
35085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35087 if (SWIG_arg_fail(1)) SWIG_fail;
35088 {
35089 arg2 = (int)(SWIG_As_int(obj1));
35090 if (SWIG_arg_fail(2)) SWIG_fail;
35091 }
35092 {
35093 PyThreadState* __tstate = wxPyBeginAllowThreads();
35094 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35095
35096 wxPyEndAllowThreads(__tstate);
35097 if (PyErr_Occurred()) SWIG_fail;
35098 }
35099 {
35100 #if wxUSE_UNICODE
35101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35102 #else
35103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35104 #endif
35105 }
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35113 PyObject *resultobj;
35114 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35115 int arg2 ;
35116 wxString *arg3 = 0 ;
35117 bool temp3 = false ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 PyObject * obj2 = 0 ;
35121 char *kwnames[] = {
35122 (char *) "self",(char *) "id",(char *) "helpString", NULL
35123 };
35124
35125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) 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 = (int)(SWIG_As_int(obj1));
35130 if (SWIG_arg_fail(2)) SWIG_fail;
35131 }
35132 {
35133 arg3 = wxString_in_helper(obj2);
35134 if (arg3 == NULL) SWIG_fail;
35135 temp3 = true;
35136 }
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35140
35141 wxPyEndAllowThreads(__tstate);
35142 if (PyErr_Occurred()) SWIG_fail;
35143 }
35144 Py_INCREF(Py_None); resultobj = Py_None;
35145 {
35146 if (temp3)
35147 delete arg3;
35148 }
35149 return resultobj;
35150 fail:
35151 {
35152 if (temp3)
35153 delete arg3;
35154 }
35155 return NULL;
35156 }
35157
35158
35159 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35160 PyObject *resultobj;
35161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35162 int arg2 ;
35163 wxString result;
35164 PyObject * obj0 = 0 ;
35165 PyObject * obj1 = 0 ;
35166 char *kwnames[] = {
35167 (char *) "self",(char *) "id", NULL
35168 };
35169
35170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35172 if (SWIG_arg_fail(1)) SWIG_fail;
35173 {
35174 arg2 = (int)(SWIG_As_int(obj1));
35175 if (SWIG_arg_fail(2)) SWIG_fail;
35176 }
35177 {
35178 PyThreadState* __tstate = wxPyBeginAllowThreads();
35179 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35180
35181 wxPyEndAllowThreads(__tstate);
35182 if (PyErr_Occurred()) SWIG_fail;
35183 }
35184 {
35185 #if wxUSE_UNICODE
35186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35187 #else
35188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35189 #endif
35190 }
35191 return resultobj;
35192 fail:
35193 return NULL;
35194 }
35195
35196
35197 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35198 PyObject *resultobj;
35199 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35200 wxFrame *result;
35201 PyObject * obj0 = 0 ;
35202 char *kwnames[] = {
35203 (char *) "self", NULL
35204 };
35205
35206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35208 if (SWIG_arg_fail(1)) SWIG_fail;
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35212
35213 wxPyEndAllowThreads(__tstate);
35214 if (PyErr_Occurred()) SWIG_fail;
35215 }
35216 {
35217 resultobj = wxPyMake_wxObject(result, 0);
35218 }
35219 return resultobj;
35220 fail:
35221 return NULL;
35222 }
35223
35224
35225 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35226 PyObject *resultobj;
35227 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35228 bool result;
35229 PyObject * obj0 = 0 ;
35230 char *kwnames[] = {
35231 (char *) "self", NULL
35232 };
35233
35234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35236 if (SWIG_arg_fail(1)) SWIG_fail;
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35240
35241 wxPyEndAllowThreads(__tstate);
35242 if (PyErr_Occurred()) SWIG_fail;
35243 }
35244 {
35245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35246 }
35247 return resultobj;
35248 fail:
35249 return NULL;
35250 }
35251
35252
35253 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35254 PyObject *resultobj;
35255 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35256 wxFrame *arg2 = (wxFrame *) 0 ;
35257 PyObject * obj0 = 0 ;
35258 PyObject * obj1 = 0 ;
35259 char *kwnames[] = {
35260 (char *) "self",(char *) "frame", NULL
35261 };
35262
35263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35265 if (SWIG_arg_fail(1)) SWIG_fail;
35266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35267 if (SWIG_arg_fail(2)) SWIG_fail;
35268 {
35269 PyThreadState* __tstate = wxPyBeginAllowThreads();
35270 (arg1)->Attach(arg2);
35271
35272 wxPyEndAllowThreads(__tstate);
35273 if (PyErr_Occurred()) SWIG_fail;
35274 }
35275 Py_INCREF(Py_None); resultobj = Py_None;
35276 return resultobj;
35277 fail:
35278 return NULL;
35279 }
35280
35281
35282 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35283 PyObject *resultobj;
35284 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35285 PyObject * obj0 = 0 ;
35286 char *kwnames[] = {
35287 (char *) "self", NULL
35288 };
35289
35290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35292 if (SWIG_arg_fail(1)) SWIG_fail;
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 (arg1)->Detach();
35296
35297 wxPyEndAllowThreads(__tstate);
35298 if (PyErr_Occurred()) SWIG_fail;
35299 }
35300 Py_INCREF(Py_None); resultobj = Py_None;
35301 return resultobj;
35302 fail:
35303 return NULL;
35304 }
35305
35306
35307 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35308 PyObject *obj;
35309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35310 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35311 Py_INCREF(obj);
35312 return Py_BuildValue((char *)"");
35313 }
35314 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35315 PyObject *resultobj;
35316 wxMenu *arg1 = (wxMenu *) NULL ;
35317 int arg2 = (int) wxID_ANY ;
35318 wxString const &arg3_defvalue = wxPyEmptyString ;
35319 wxString *arg3 = (wxString *) &arg3_defvalue ;
35320 wxString const &arg4_defvalue = wxPyEmptyString ;
35321 wxString *arg4 = (wxString *) &arg4_defvalue ;
35322 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35323 wxMenu *arg6 = (wxMenu *) NULL ;
35324 wxMenuItem *result;
35325 bool temp3 = false ;
35326 bool temp4 = false ;
35327 PyObject * obj0 = 0 ;
35328 PyObject * obj1 = 0 ;
35329 PyObject * obj2 = 0 ;
35330 PyObject * obj3 = 0 ;
35331 PyObject * obj4 = 0 ;
35332 PyObject * obj5 = 0 ;
35333 char *kwnames[] = {
35334 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35335 };
35336
35337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35338 if (obj0) {
35339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35340 if (SWIG_arg_fail(1)) SWIG_fail;
35341 }
35342 if (obj1) {
35343 {
35344 arg2 = (int)(SWIG_As_int(obj1));
35345 if (SWIG_arg_fail(2)) SWIG_fail;
35346 }
35347 }
35348 if (obj2) {
35349 {
35350 arg3 = wxString_in_helper(obj2);
35351 if (arg3 == NULL) SWIG_fail;
35352 temp3 = true;
35353 }
35354 }
35355 if (obj3) {
35356 {
35357 arg4 = wxString_in_helper(obj3);
35358 if (arg4 == NULL) SWIG_fail;
35359 temp4 = true;
35360 }
35361 }
35362 if (obj4) {
35363 {
35364 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35365 if (SWIG_arg_fail(5)) SWIG_fail;
35366 }
35367 }
35368 if (obj5) {
35369 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35370 if (SWIG_arg_fail(6)) SWIG_fail;
35371 }
35372 {
35373 PyThreadState* __tstate = wxPyBeginAllowThreads();
35374 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35375
35376 wxPyEndAllowThreads(__tstate);
35377 if (PyErr_Occurred()) SWIG_fail;
35378 }
35379 {
35380 resultobj = wxPyMake_wxObject(result, 1);
35381 }
35382 {
35383 if (temp3)
35384 delete arg3;
35385 }
35386 {
35387 if (temp4)
35388 delete arg4;
35389 }
35390 return resultobj;
35391 fail:
35392 {
35393 if (temp3)
35394 delete arg3;
35395 }
35396 {
35397 if (temp4)
35398 delete arg4;
35399 }
35400 return NULL;
35401 }
35402
35403
35404 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35405 PyObject *resultobj;
35406 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35407 wxMenu *result;
35408 PyObject * obj0 = 0 ;
35409 char *kwnames[] = {
35410 (char *) "self", NULL
35411 };
35412
35413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35415 if (SWIG_arg_fail(1)) SWIG_fail;
35416 {
35417 PyThreadState* __tstate = wxPyBeginAllowThreads();
35418 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35419
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 {
35424 resultobj = wxPyMake_wxObject(result, 0);
35425 }
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35433 PyObject *resultobj;
35434 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35435 wxMenu *arg2 = (wxMenu *) 0 ;
35436 PyObject * obj0 = 0 ;
35437 PyObject * obj1 = 0 ;
35438 char *kwnames[] = {
35439 (char *) "self",(char *) "menu", NULL
35440 };
35441
35442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35444 if (SWIG_arg_fail(1)) SWIG_fail;
35445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35446 if (SWIG_arg_fail(2)) SWIG_fail;
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 (arg1)->SetMenu(arg2);
35450
35451 wxPyEndAllowThreads(__tstate);
35452 if (PyErr_Occurred()) SWIG_fail;
35453 }
35454 Py_INCREF(Py_None); resultobj = Py_None;
35455 return resultobj;
35456 fail:
35457 return NULL;
35458 }
35459
35460
35461 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35462 PyObject *resultobj;
35463 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35464 int arg2 ;
35465 PyObject * obj0 = 0 ;
35466 PyObject * obj1 = 0 ;
35467 char *kwnames[] = {
35468 (char *) "self",(char *) "id", NULL
35469 };
35470
35471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35473 if (SWIG_arg_fail(1)) SWIG_fail;
35474 {
35475 arg2 = (int)(SWIG_As_int(obj1));
35476 if (SWIG_arg_fail(2)) SWIG_fail;
35477 }
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 (arg1)->SetId(arg2);
35481
35482 wxPyEndAllowThreads(__tstate);
35483 if (PyErr_Occurred()) SWIG_fail;
35484 }
35485 Py_INCREF(Py_None); resultobj = Py_None;
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35493 PyObject *resultobj;
35494 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35495 int result;
35496 PyObject * obj0 = 0 ;
35497 char *kwnames[] = {
35498 (char *) "self", NULL
35499 };
35500
35501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35503 if (SWIG_arg_fail(1)) SWIG_fail;
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 result = (int)((wxMenuItem const *)arg1)->GetId();
35507
35508 wxPyEndAllowThreads(__tstate);
35509 if (PyErr_Occurred()) SWIG_fail;
35510 }
35511 {
35512 resultobj = SWIG_From_int((int)(result));
35513 }
35514 return resultobj;
35515 fail:
35516 return NULL;
35517 }
35518
35519
35520 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35521 PyObject *resultobj;
35522 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35523 bool result;
35524 PyObject * obj0 = 0 ;
35525 char *kwnames[] = {
35526 (char *) "self", NULL
35527 };
35528
35529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35531 if (SWIG_arg_fail(1)) SWIG_fail;
35532 {
35533 PyThreadState* __tstate = wxPyBeginAllowThreads();
35534 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35535
35536 wxPyEndAllowThreads(__tstate);
35537 if (PyErr_Occurred()) SWIG_fail;
35538 }
35539 {
35540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35541 }
35542 return resultobj;
35543 fail:
35544 return NULL;
35545 }
35546
35547
35548 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35549 PyObject *resultobj;
35550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35551 wxString *arg2 = 0 ;
35552 bool temp2 = false ;
35553 PyObject * obj0 = 0 ;
35554 PyObject * obj1 = 0 ;
35555 char *kwnames[] = {
35556 (char *) "self",(char *) "str", NULL
35557 };
35558
35559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35561 if (SWIG_arg_fail(1)) SWIG_fail;
35562 {
35563 arg2 = wxString_in_helper(obj1);
35564 if (arg2 == NULL) SWIG_fail;
35565 temp2 = true;
35566 }
35567 {
35568 PyThreadState* __tstate = wxPyBeginAllowThreads();
35569 (arg1)->SetText((wxString const &)*arg2);
35570
35571 wxPyEndAllowThreads(__tstate);
35572 if (PyErr_Occurred()) SWIG_fail;
35573 }
35574 Py_INCREF(Py_None); resultobj = Py_None;
35575 {
35576 if (temp2)
35577 delete arg2;
35578 }
35579 return resultobj;
35580 fail:
35581 {
35582 if (temp2)
35583 delete arg2;
35584 }
35585 return NULL;
35586 }
35587
35588
35589 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35590 PyObject *resultobj;
35591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35592 wxString result;
35593 PyObject * obj0 = 0 ;
35594 char *kwnames[] = {
35595 (char *) "self", NULL
35596 };
35597
35598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35600 if (SWIG_arg_fail(1)) SWIG_fail;
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 result = ((wxMenuItem const *)arg1)->GetLabel();
35604
35605 wxPyEndAllowThreads(__tstate);
35606 if (PyErr_Occurred()) SWIG_fail;
35607 }
35608 {
35609 #if wxUSE_UNICODE
35610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35611 #else
35612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35613 #endif
35614 }
35615 return resultobj;
35616 fail:
35617 return NULL;
35618 }
35619
35620
35621 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35622 PyObject *resultobj;
35623 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35624 wxString *result;
35625 PyObject * obj0 = 0 ;
35626 char *kwnames[] = {
35627 (char *) "self", NULL
35628 };
35629
35630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35632 if (SWIG_arg_fail(1)) SWIG_fail;
35633 {
35634 PyThreadState* __tstate = wxPyBeginAllowThreads();
35635 {
35636 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35637 result = (wxString *) &_result_ref;
35638 }
35639
35640 wxPyEndAllowThreads(__tstate);
35641 if (PyErr_Occurred()) SWIG_fail;
35642 }
35643 {
35644 #if wxUSE_UNICODE
35645 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35646 #else
35647 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35648 #endif
35649 }
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj;
35658 wxString *arg1 = 0 ;
35659 wxString result;
35660 bool temp1 = false ;
35661 PyObject * obj0 = 0 ;
35662 char *kwnames[] = {
35663 (char *) "text", NULL
35664 };
35665
35666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35667 {
35668 arg1 = wxString_in_helper(obj0);
35669 if (arg1 == NULL) SWIG_fail;
35670 temp1 = true;
35671 }
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35675
35676 wxPyEndAllowThreads(__tstate);
35677 if (PyErr_Occurred()) SWIG_fail;
35678 }
35679 {
35680 #if wxUSE_UNICODE
35681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35682 #else
35683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35684 #endif
35685 }
35686 {
35687 if (temp1)
35688 delete arg1;
35689 }
35690 return resultobj;
35691 fail:
35692 {
35693 if (temp1)
35694 delete arg1;
35695 }
35696 return NULL;
35697 }
35698
35699
35700 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35701 PyObject *resultobj;
35702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35703 wxItemKind result;
35704 PyObject * obj0 = 0 ;
35705 char *kwnames[] = {
35706 (char *) "self", NULL
35707 };
35708
35709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35711 if (SWIG_arg_fail(1)) SWIG_fail;
35712 {
35713 PyThreadState* __tstate = wxPyBeginAllowThreads();
35714 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35715
35716 wxPyEndAllowThreads(__tstate);
35717 if (PyErr_Occurred()) SWIG_fail;
35718 }
35719 resultobj = SWIG_From_int((result));
35720 return resultobj;
35721 fail:
35722 return NULL;
35723 }
35724
35725
35726 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35727 PyObject *resultobj;
35728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35729 wxItemKind arg2 ;
35730 PyObject * obj0 = 0 ;
35731 PyObject * obj1 = 0 ;
35732 char *kwnames[] = {
35733 (char *) "self",(char *) "kind", NULL
35734 };
35735
35736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35738 if (SWIG_arg_fail(1)) SWIG_fail;
35739 {
35740 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35741 if (SWIG_arg_fail(2)) SWIG_fail;
35742 }
35743 {
35744 PyThreadState* __tstate = wxPyBeginAllowThreads();
35745 (arg1)->SetKind((wxItemKind )arg2);
35746
35747 wxPyEndAllowThreads(__tstate);
35748 if (PyErr_Occurred()) SWIG_fail;
35749 }
35750 Py_INCREF(Py_None); resultobj = Py_None;
35751 return resultobj;
35752 fail:
35753 return NULL;
35754 }
35755
35756
35757 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35758 PyObject *resultobj;
35759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35760 bool arg2 ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 char *kwnames[] = {
35764 (char *) "self",(char *) "checkable", NULL
35765 };
35766
35767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35769 if (SWIG_arg_fail(1)) SWIG_fail;
35770 {
35771 arg2 = (bool)(SWIG_As_bool(obj1));
35772 if (SWIG_arg_fail(2)) SWIG_fail;
35773 }
35774 {
35775 PyThreadState* __tstate = wxPyBeginAllowThreads();
35776 (arg1)->SetCheckable(arg2);
35777
35778 wxPyEndAllowThreads(__tstate);
35779 if (PyErr_Occurred()) SWIG_fail;
35780 }
35781 Py_INCREF(Py_None); resultobj = Py_None;
35782 return resultobj;
35783 fail:
35784 return NULL;
35785 }
35786
35787
35788 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35789 PyObject *resultobj;
35790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35791 bool result;
35792 PyObject * obj0 = 0 ;
35793 char *kwnames[] = {
35794 (char *) "self", NULL
35795 };
35796
35797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35799 if (SWIG_arg_fail(1)) SWIG_fail;
35800 {
35801 PyThreadState* __tstate = wxPyBeginAllowThreads();
35802 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35803
35804 wxPyEndAllowThreads(__tstate);
35805 if (PyErr_Occurred()) SWIG_fail;
35806 }
35807 {
35808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35809 }
35810 return resultobj;
35811 fail:
35812 return NULL;
35813 }
35814
35815
35816 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35817 PyObject *resultobj;
35818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35819 bool result;
35820 PyObject * obj0 = 0 ;
35821 char *kwnames[] = {
35822 (char *) "self", NULL
35823 };
35824
35825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35827 if (SWIG_arg_fail(1)) SWIG_fail;
35828 {
35829 PyThreadState* __tstate = wxPyBeginAllowThreads();
35830 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35831
35832 wxPyEndAllowThreads(__tstate);
35833 if (PyErr_Occurred()) SWIG_fail;
35834 }
35835 {
35836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35837 }
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35845 PyObject *resultobj;
35846 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35847 wxMenu *arg2 = (wxMenu *) 0 ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 char *kwnames[] = {
35851 (char *) "self",(char *) "menu", NULL
35852 };
35853
35854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35856 if (SWIG_arg_fail(1)) SWIG_fail;
35857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35858 if (SWIG_arg_fail(2)) SWIG_fail;
35859 {
35860 PyThreadState* __tstate = wxPyBeginAllowThreads();
35861 (arg1)->SetSubMenu(arg2);
35862
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 Py_INCREF(Py_None); resultobj = Py_None;
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35874 PyObject *resultobj;
35875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35876 wxMenu *result;
35877 PyObject * obj0 = 0 ;
35878 char *kwnames[] = {
35879 (char *) "self", NULL
35880 };
35881
35882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35884 if (SWIG_arg_fail(1)) SWIG_fail;
35885 {
35886 PyThreadState* __tstate = wxPyBeginAllowThreads();
35887 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35888
35889 wxPyEndAllowThreads(__tstate);
35890 if (PyErr_Occurred()) SWIG_fail;
35891 }
35892 {
35893 resultobj = wxPyMake_wxObject(result, 0);
35894 }
35895 return resultobj;
35896 fail:
35897 return NULL;
35898 }
35899
35900
35901 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35902 PyObject *resultobj;
35903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35904 bool arg2 = (bool) true ;
35905 PyObject * obj0 = 0 ;
35906 PyObject * obj1 = 0 ;
35907 char *kwnames[] = {
35908 (char *) "self",(char *) "enable", NULL
35909 };
35910
35911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35913 if (SWIG_arg_fail(1)) SWIG_fail;
35914 if (obj1) {
35915 {
35916 arg2 = (bool)(SWIG_As_bool(obj1));
35917 if (SWIG_arg_fail(2)) SWIG_fail;
35918 }
35919 }
35920 {
35921 PyThreadState* __tstate = wxPyBeginAllowThreads();
35922 (arg1)->Enable(arg2);
35923
35924 wxPyEndAllowThreads(__tstate);
35925 if (PyErr_Occurred()) SWIG_fail;
35926 }
35927 Py_INCREF(Py_None); resultobj = Py_None;
35928 return resultobj;
35929 fail:
35930 return NULL;
35931 }
35932
35933
35934 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35935 PyObject *resultobj;
35936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35937 bool result;
35938 PyObject * obj0 = 0 ;
35939 char *kwnames[] = {
35940 (char *) "self", NULL
35941 };
35942
35943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35945 if (SWIG_arg_fail(1)) SWIG_fail;
35946 {
35947 PyThreadState* __tstate = wxPyBeginAllowThreads();
35948 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35949
35950 wxPyEndAllowThreads(__tstate);
35951 if (PyErr_Occurred()) SWIG_fail;
35952 }
35953 {
35954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35955 }
35956 return resultobj;
35957 fail:
35958 return NULL;
35959 }
35960
35961
35962 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35963 PyObject *resultobj;
35964 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35965 bool arg2 = (bool) true ;
35966 PyObject * obj0 = 0 ;
35967 PyObject * obj1 = 0 ;
35968 char *kwnames[] = {
35969 (char *) "self",(char *) "check", NULL
35970 };
35971
35972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35974 if (SWIG_arg_fail(1)) SWIG_fail;
35975 if (obj1) {
35976 {
35977 arg2 = (bool)(SWIG_As_bool(obj1));
35978 if (SWIG_arg_fail(2)) SWIG_fail;
35979 }
35980 }
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 (arg1)->Check(arg2);
35984
35985 wxPyEndAllowThreads(__tstate);
35986 if (PyErr_Occurred()) SWIG_fail;
35987 }
35988 Py_INCREF(Py_None); resultobj = Py_None;
35989 return resultobj;
35990 fail:
35991 return NULL;
35992 }
35993
35994
35995 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35996 PyObject *resultobj;
35997 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35998 bool result;
35999 PyObject * obj0 = 0 ;
36000 char *kwnames[] = {
36001 (char *) "self", NULL
36002 };
36003
36004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36006 if (SWIG_arg_fail(1)) SWIG_fail;
36007 {
36008 PyThreadState* __tstate = wxPyBeginAllowThreads();
36009 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36010
36011 wxPyEndAllowThreads(__tstate);
36012 if (PyErr_Occurred()) SWIG_fail;
36013 }
36014 {
36015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36016 }
36017 return resultobj;
36018 fail:
36019 return NULL;
36020 }
36021
36022
36023 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36024 PyObject *resultobj;
36025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36026 PyObject * obj0 = 0 ;
36027 char *kwnames[] = {
36028 (char *) "self", NULL
36029 };
36030
36031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36033 if (SWIG_arg_fail(1)) SWIG_fail;
36034 {
36035 PyThreadState* __tstate = wxPyBeginAllowThreads();
36036 (arg1)->Toggle();
36037
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 Py_INCREF(Py_None); resultobj = Py_None;
36042 return resultobj;
36043 fail:
36044 return NULL;
36045 }
36046
36047
36048 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36049 PyObject *resultobj;
36050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36051 wxString *arg2 = 0 ;
36052 bool temp2 = false ;
36053 PyObject * obj0 = 0 ;
36054 PyObject * obj1 = 0 ;
36055 char *kwnames[] = {
36056 (char *) "self",(char *) "str", NULL
36057 };
36058
36059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36061 if (SWIG_arg_fail(1)) SWIG_fail;
36062 {
36063 arg2 = wxString_in_helper(obj1);
36064 if (arg2 == NULL) SWIG_fail;
36065 temp2 = true;
36066 }
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 (arg1)->SetHelp((wxString const &)*arg2);
36070
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 Py_INCREF(Py_None); resultobj = Py_None;
36075 {
36076 if (temp2)
36077 delete arg2;
36078 }
36079 return resultobj;
36080 fail:
36081 {
36082 if (temp2)
36083 delete arg2;
36084 }
36085 return NULL;
36086 }
36087
36088
36089 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36090 PyObject *resultobj;
36091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36092 wxString *result;
36093 PyObject * obj0 = 0 ;
36094 char *kwnames[] = {
36095 (char *) "self", NULL
36096 };
36097
36098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36100 if (SWIG_arg_fail(1)) SWIG_fail;
36101 {
36102 PyThreadState* __tstate = wxPyBeginAllowThreads();
36103 {
36104 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36105 result = (wxString *) &_result_ref;
36106 }
36107
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 {
36112 #if wxUSE_UNICODE
36113 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36114 #else
36115 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36116 #endif
36117 }
36118 return resultobj;
36119 fail:
36120 return NULL;
36121 }
36122
36123
36124 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36125 PyObject *resultobj;
36126 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36127 wxAcceleratorEntry *result;
36128 PyObject * obj0 = 0 ;
36129 char *kwnames[] = {
36130 (char *) "self", NULL
36131 };
36132
36133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36135 if (SWIG_arg_fail(1)) SWIG_fail;
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36139
36140 wxPyEndAllowThreads(__tstate);
36141 if (PyErr_Occurred()) SWIG_fail;
36142 }
36143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36144 return resultobj;
36145 fail:
36146 return NULL;
36147 }
36148
36149
36150 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36151 PyObject *resultobj;
36152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36153 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36154 PyObject * obj0 = 0 ;
36155 PyObject * obj1 = 0 ;
36156 char *kwnames[] = {
36157 (char *) "self",(char *) "accel", NULL
36158 };
36159
36160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36162 if (SWIG_arg_fail(1)) SWIG_fail;
36163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36164 if (SWIG_arg_fail(2)) SWIG_fail;
36165 {
36166 PyThreadState* __tstate = wxPyBeginAllowThreads();
36167 (arg1)->SetAccel(arg2);
36168
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 Py_INCREF(Py_None); resultobj = Py_None;
36173 return resultobj;
36174 fail:
36175 return NULL;
36176 }
36177
36178
36179 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36180 PyObject *resultobj;
36181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36182 wxFont *arg2 = 0 ;
36183 PyObject * obj0 = 0 ;
36184 PyObject * obj1 = 0 ;
36185 char *kwnames[] = {
36186 (char *) "self",(char *) "font", NULL
36187 };
36188
36189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36191 if (SWIG_arg_fail(1)) SWIG_fail;
36192 {
36193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36194 if (SWIG_arg_fail(2)) SWIG_fail;
36195 if (arg2 == NULL) {
36196 SWIG_null_ref("wxFont");
36197 }
36198 if (SWIG_arg_fail(2)) SWIG_fail;
36199 }
36200 {
36201 PyThreadState* __tstate = wxPyBeginAllowThreads();
36202 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36203
36204 wxPyEndAllowThreads(__tstate);
36205 if (PyErr_Occurred()) SWIG_fail;
36206 }
36207 Py_INCREF(Py_None); resultobj = Py_None;
36208 return resultobj;
36209 fail:
36210 return NULL;
36211 }
36212
36213
36214 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36215 PyObject *resultobj;
36216 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36217 wxFont result;
36218 PyObject * obj0 = 0 ;
36219 char *kwnames[] = {
36220 (char *) "self", NULL
36221 };
36222
36223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36225 if (SWIG_arg_fail(1)) SWIG_fail;
36226 {
36227 PyThreadState* __tstate = wxPyBeginAllowThreads();
36228 result = wxMenuItem_GetFont(arg1);
36229
36230 wxPyEndAllowThreads(__tstate);
36231 if (PyErr_Occurred()) SWIG_fail;
36232 }
36233 {
36234 wxFont * resultptr;
36235 resultptr = new wxFont((wxFont &)(result));
36236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36237 }
36238 return resultobj;
36239 fail:
36240 return NULL;
36241 }
36242
36243
36244 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36245 PyObject *resultobj;
36246 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36247 wxColour *arg2 = 0 ;
36248 wxColour temp2 ;
36249 PyObject * obj0 = 0 ;
36250 PyObject * obj1 = 0 ;
36251 char *kwnames[] = {
36252 (char *) "self",(char *) "colText", NULL
36253 };
36254
36255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36257 if (SWIG_arg_fail(1)) SWIG_fail;
36258 {
36259 arg2 = &temp2;
36260 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36261 }
36262 {
36263 PyThreadState* __tstate = wxPyBeginAllowThreads();
36264 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36265
36266 wxPyEndAllowThreads(__tstate);
36267 if (PyErr_Occurred()) SWIG_fail;
36268 }
36269 Py_INCREF(Py_None); resultobj = Py_None;
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36277 PyObject *resultobj;
36278 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36279 wxColour result;
36280 PyObject * obj0 = 0 ;
36281 char *kwnames[] = {
36282 (char *) "self", NULL
36283 };
36284
36285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36287 if (SWIG_arg_fail(1)) SWIG_fail;
36288 {
36289 PyThreadState* __tstate = wxPyBeginAllowThreads();
36290 result = wxMenuItem_GetTextColour(arg1);
36291
36292 wxPyEndAllowThreads(__tstate);
36293 if (PyErr_Occurred()) SWIG_fail;
36294 }
36295 {
36296 wxColour * resultptr;
36297 resultptr = new wxColour((wxColour &)(result));
36298 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36299 }
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36307 PyObject *resultobj;
36308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36309 wxColour *arg2 = 0 ;
36310 wxColour temp2 ;
36311 PyObject * obj0 = 0 ;
36312 PyObject * obj1 = 0 ;
36313 char *kwnames[] = {
36314 (char *) "self",(char *) "colBack", NULL
36315 };
36316
36317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36319 if (SWIG_arg_fail(1)) SWIG_fail;
36320 {
36321 arg2 = &temp2;
36322 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36323 }
36324 {
36325 PyThreadState* __tstate = wxPyBeginAllowThreads();
36326 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36327
36328 wxPyEndAllowThreads(__tstate);
36329 if (PyErr_Occurred()) SWIG_fail;
36330 }
36331 Py_INCREF(Py_None); resultobj = Py_None;
36332 return resultobj;
36333 fail:
36334 return NULL;
36335 }
36336
36337
36338 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36339 PyObject *resultobj;
36340 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36341 wxColour result;
36342 PyObject * obj0 = 0 ;
36343 char *kwnames[] = {
36344 (char *) "self", NULL
36345 };
36346
36347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36349 if (SWIG_arg_fail(1)) SWIG_fail;
36350 {
36351 PyThreadState* __tstate = wxPyBeginAllowThreads();
36352 result = wxMenuItem_GetBackgroundColour(arg1);
36353
36354 wxPyEndAllowThreads(__tstate);
36355 if (PyErr_Occurred()) SWIG_fail;
36356 }
36357 {
36358 wxColour * resultptr;
36359 resultptr = new wxColour((wxColour &)(result));
36360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36361 }
36362 return resultobj;
36363 fail:
36364 return NULL;
36365 }
36366
36367
36368 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36369 PyObject *resultobj;
36370 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36371 wxBitmap *arg2 = 0 ;
36372 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36373 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36374 PyObject * obj0 = 0 ;
36375 PyObject * obj1 = 0 ;
36376 PyObject * obj2 = 0 ;
36377 char *kwnames[] = {
36378 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36379 };
36380
36381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36383 if (SWIG_arg_fail(1)) SWIG_fail;
36384 {
36385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36386 if (SWIG_arg_fail(2)) SWIG_fail;
36387 if (arg2 == NULL) {
36388 SWIG_null_ref("wxBitmap");
36389 }
36390 if (SWIG_arg_fail(2)) SWIG_fail;
36391 }
36392 if (obj2) {
36393 {
36394 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36395 if (SWIG_arg_fail(3)) SWIG_fail;
36396 if (arg3 == NULL) {
36397 SWIG_null_ref("wxBitmap");
36398 }
36399 if (SWIG_arg_fail(3)) SWIG_fail;
36400 }
36401 }
36402 {
36403 PyThreadState* __tstate = wxPyBeginAllowThreads();
36404 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36405
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 Py_INCREF(Py_None); resultobj = Py_None;
36410 return resultobj;
36411 fail:
36412 return NULL;
36413 }
36414
36415
36416 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36417 PyObject *resultobj;
36418 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36419 wxBitmap *arg2 = 0 ;
36420 PyObject * obj0 = 0 ;
36421 PyObject * obj1 = 0 ;
36422 char *kwnames[] = {
36423 (char *) "self",(char *) "bmpDisabled", NULL
36424 };
36425
36426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36428 if (SWIG_arg_fail(1)) SWIG_fail;
36429 {
36430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36431 if (SWIG_arg_fail(2)) SWIG_fail;
36432 if (arg2 == NULL) {
36433 SWIG_null_ref("wxBitmap");
36434 }
36435 if (SWIG_arg_fail(2)) SWIG_fail;
36436 }
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36440
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 Py_INCREF(Py_None); resultobj = Py_None;
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj;
36453 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36454 wxBitmap *result;
36455 PyObject * obj0 = 0 ;
36456 char *kwnames[] = {
36457 (char *) "self", NULL
36458 };
36459
36460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36462 if (SWIG_arg_fail(1)) SWIG_fail;
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 {
36466 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
36467 result = (wxBitmap *) &_result_ref;
36468 }
36469
36470 wxPyEndAllowThreads(__tstate);
36471 if (PyErr_Occurred()) SWIG_fail;
36472 }
36473 {
36474 wxBitmap* resultptr = new wxBitmap(*result);
36475 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36476 }
36477 return resultobj;
36478 fail:
36479 return NULL;
36480 }
36481
36482
36483 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36484 PyObject *resultobj;
36485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36486 int arg2 ;
36487 PyObject * obj0 = 0 ;
36488 PyObject * obj1 = 0 ;
36489 char *kwnames[] = {
36490 (char *) "self",(char *) "nWidth", NULL
36491 };
36492
36493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36495 if (SWIG_arg_fail(1)) SWIG_fail;
36496 {
36497 arg2 = (int)(SWIG_As_int(obj1));
36498 if (SWIG_arg_fail(2)) SWIG_fail;
36499 }
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 wxMenuItem_SetMarginWidth(arg1,arg2);
36503
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 Py_INCREF(Py_None); resultobj = Py_None;
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36515 PyObject *resultobj;
36516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36517 int result;
36518 PyObject * obj0 = 0 ;
36519 char *kwnames[] = {
36520 (char *) "self", NULL
36521 };
36522
36523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36525 if (SWIG_arg_fail(1)) SWIG_fail;
36526 {
36527 PyThreadState* __tstate = wxPyBeginAllowThreads();
36528 result = (int)wxMenuItem_GetMarginWidth(arg1);
36529
36530 wxPyEndAllowThreads(__tstate);
36531 if (PyErr_Occurred()) SWIG_fail;
36532 }
36533 {
36534 resultobj = SWIG_From_int((int)(result));
36535 }
36536 return resultobj;
36537 fail:
36538 return NULL;
36539 }
36540
36541
36542 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36543 PyObject *resultobj;
36544 int result;
36545 char *kwnames[] = {
36546 NULL
36547 };
36548
36549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36550 {
36551 PyThreadState* __tstate = wxPyBeginAllowThreads();
36552 result = (int)MenuItem_GetDefaultMarginWidth();
36553
36554 wxPyEndAllowThreads(__tstate);
36555 if (PyErr_Occurred()) SWIG_fail;
36556 }
36557 {
36558 resultobj = SWIG_From_int((int)(result));
36559 }
36560 return resultobj;
36561 fail:
36562 return NULL;
36563 }
36564
36565
36566 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36567 PyObject *resultobj;
36568 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36569 bool result;
36570 PyObject * obj0 = 0 ;
36571 char *kwnames[] = {
36572 (char *) "self", NULL
36573 };
36574
36575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36577 if (SWIG_arg_fail(1)) SWIG_fail;
36578 {
36579 PyThreadState* __tstate = wxPyBeginAllowThreads();
36580 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
36581
36582 wxPyEndAllowThreads(__tstate);
36583 if (PyErr_Occurred()) SWIG_fail;
36584 }
36585 {
36586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36587 }
36588 return resultobj;
36589 fail:
36590 return NULL;
36591 }
36592
36593
36594 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36595 PyObject *resultobj;
36596 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36597 bool arg2 = (bool) true ;
36598 PyObject * obj0 = 0 ;
36599 PyObject * obj1 = 0 ;
36600 char *kwnames[] = {
36601 (char *) "self",(char *) "ownerDrawn", NULL
36602 };
36603
36604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36606 if (SWIG_arg_fail(1)) SWIG_fail;
36607 if (obj1) {
36608 {
36609 arg2 = (bool)(SWIG_As_bool(obj1));
36610 if (SWIG_arg_fail(2)) SWIG_fail;
36611 }
36612 }
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 wxMenuItem_SetOwnerDrawn(arg1,arg2);
36616
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 Py_INCREF(Py_None); resultobj = Py_None;
36621 return resultobj;
36622 fail:
36623 return NULL;
36624 }
36625
36626
36627 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36628 PyObject *resultobj;
36629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36630 PyObject * obj0 = 0 ;
36631 char *kwnames[] = {
36632 (char *) "self", NULL
36633 };
36634
36635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36637 if (SWIG_arg_fail(1)) SWIG_fail;
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 wxMenuItem_ResetOwnerDrawn(arg1);
36641
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 Py_INCREF(Py_None); resultobj = Py_None;
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj;
36654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36655 wxBitmap *arg2 = 0 ;
36656 PyObject * obj0 = 0 ;
36657 PyObject * obj1 = 0 ;
36658 char *kwnames[] = {
36659 (char *) "self",(char *) "bitmap", NULL
36660 };
36661
36662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36664 if (SWIG_arg_fail(1)) SWIG_fail;
36665 {
36666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36667 if (SWIG_arg_fail(2)) SWIG_fail;
36668 if (arg2 == NULL) {
36669 SWIG_null_ref("wxBitmap");
36670 }
36671 if (SWIG_arg_fail(2)) SWIG_fail;
36672 }
36673 {
36674 PyThreadState* __tstate = wxPyBeginAllowThreads();
36675 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36676
36677 wxPyEndAllowThreads(__tstate);
36678 if (PyErr_Occurred()) SWIG_fail;
36679 }
36680 Py_INCREF(Py_None); resultobj = Py_None;
36681 return resultobj;
36682 fail:
36683 return NULL;
36684 }
36685
36686
36687 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36688 PyObject *resultobj;
36689 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36690 wxBitmap *result;
36691 PyObject * obj0 = 0 ;
36692 char *kwnames[] = {
36693 (char *) "self", NULL
36694 };
36695
36696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36698 if (SWIG_arg_fail(1)) SWIG_fail;
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 {
36702 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36703 result = (wxBitmap *) &_result_ref;
36704 }
36705
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 {
36710 wxBitmap* resultptr = new wxBitmap(*result);
36711 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36712 }
36713 return resultobj;
36714 fail:
36715 return NULL;
36716 }
36717
36718
36719 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36720 PyObject *obj;
36721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36722 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36723 Py_INCREF(obj);
36724 return Py_BuildValue((char *)"");
36725 }
36726 static int _wrap_ControlNameStr_set(PyObject *) {
36727 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36728 return 1;
36729 }
36730
36731
36732 static PyObject *_wrap_ControlNameStr_get(void) {
36733 PyObject *pyobj;
36734
36735 {
36736 #if wxUSE_UNICODE
36737 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36738 #else
36739 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36740 #endif
36741 }
36742 return pyobj;
36743 }
36744
36745
36746 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36747 PyObject *resultobj;
36748 wxWindow *arg1 = (wxWindow *) 0 ;
36749 int arg2 = (int) -1 ;
36750 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36751 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36752 wxSize const &arg4_defvalue = wxDefaultSize ;
36753 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36754 long arg5 = (long) 0 ;
36755 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36756 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36757 wxString const &arg7_defvalue = wxPyControlNameStr ;
36758 wxString *arg7 = (wxString *) &arg7_defvalue ;
36759 wxControl *result;
36760 wxPoint temp3 ;
36761 wxSize temp4 ;
36762 bool temp7 = false ;
36763 PyObject * obj0 = 0 ;
36764 PyObject * obj1 = 0 ;
36765 PyObject * obj2 = 0 ;
36766 PyObject * obj3 = 0 ;
36767 PyObject * obj4 = 0 ;
36768 PyObject * obj5 = 0 ;
36769 PyObject * obj6 = 0 ;
36770 char *kwnames[] = {
36771 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36772 };
36773
36774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36776 if (SWIG_arg_fail(1)) SWIG_fail;
36777 if (obj1) {
36778 {
36779 arg2 = (int)(SWIG_As_int(obj1));
36780 if (SWIG_arg_fail(2)) SWIG_fail;
36781 }
36782 }
36783 if (obj2) {
36784 {
36785 arg3 = &temp3;
36786 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36787 }
36788 }
36789 if (obj3) {
36790 {
36791 arg4 = &temp4;
36792 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36793 }
36794 }
36795 if (obj4) {
36796 {
36797 arg5 = (long)(SWIG_As_long(obj4));
36798 if (SWIG_arg_fail(5)) SWIG_fail;
36799 }
36800 }
36801 if (obj5) {
36802 {
36803 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36804 if (SWIG_arg_fail(6)) SWIG_fail;
36805 if (arg6 == NULL) {
36806 SWIG_null_ref("wxValidator");
36807 }
36808 if (SWIG_arg_fail(6)) SWIG_fail;
36809 }
36810 }
36811 if (obj6) {
36812 {
36813 arg7 = wxString_in_helper(obj6);
36814 if (arg7 == NULL) SWIG_fail;
36815 temp7 = true;
36816 }
36817 }
36818 {
36819 if (!wxPyCheckForApp()) SWIG_fail;
36820 PyThreadState* __tstate = wxPyBeginAllowThreads();
36821 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36822
36823 wxPyEndAllowThreads(__tstate);
36824 if (PyErr_Occurred()) SWIG_fail;
36825 }
36826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36827 {
36828 if (temp7)
36829 delete arg7;
36830 }
36831 return resultobj;
36832 fail:
36833 {
36834 if (temp7)
36835 delete arg7;
36836 }
36837 return NULL;
36838 }
36839
36840
36841 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36842 PyObject *resultobj;
36843 wxControl *result;
36844 char *kwnames[] = {
36845 NULL
36846 };
36847
36848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36849 {
36850 if (!wxPyCheckForApp()) SWIG_fail;
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 result = (wxControl *)new wxControl();
36853
36854 wxPyEndAllowThreads(__tstate);
36855 if (PyErr_Occurred()) SWIG_fail;
36856 }
36857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36858 return resultobj;
36859 fail:
36860 return NULL;
36861 }
36862
36863
36864 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36865 PyObject *resultobj;
36866 wxControl *arg1 = (wxControl *) 0 ;
36867 wxWindow *arg2 = (wxWindow *) 0 ;
36868 int arg3 = (int) -1 ;
36869 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36870 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36871 wxSize const &arg5_defvalue = wxDefaultSize ;
36872 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36873 long arg6 = (long) 0 ;
36874 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36875 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36876 wxString const &arg8_defvalue = wxPyControlNameStr ;
36877 wxString *arg8 = (wxString *) &arg8_defvalue ;
36878 bool result;
36879 wxPoint temp4 ;
36880 wxSize temp5 ;
36881 bool temp8 = false ;
36882 PyObject * obj0 = 0 ;
36883 PyObject * obj1 = 0 ;
36884 PyObject * obj2 = 0 ;
36885 PyObject * obj3 = 0 ;
36886 PyObject * obj4 = 0 ;
36887 PyObject * obj5 = 0 ;
36888 PyObject * obj6 = 0 ;
36889 PyObject * obj7 = 0 ;
36890 char *kwnames[] = {
36891 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36892 };
36893
36894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36896 if (SWIG_arg_fail(1)) SWIG_fail;
36897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36898 if (SWIG_arg_fail(2)) SWIG_fail;
36899 if (obj2) {
36900 {
36901 arg3 = (int)(SWIG_As_int(obj2));
36902 if (SWIG_arg_fail(3)) SWIG_fail;
36903 }
36904 }
36905 if (obj3) {
36906 {
36907 arg4 = &temp4;
36908 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36909 }
36910 }
36911 if (obj4) {
36912 {
36913 arg5 = &temp5;
36914 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36915 }
36916 }
36917 if (obj5) {
36918 {
36919 arg6 = (long)(SWIG_As_long(obj5));
36920 if (SWIG_arg_fail(6)) SWIG_fail;
36921 }
36922 }
36923 if (obj6) {
36924 {
36925 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36926 if (SWIG_arg_fail(7)) SWIG_fail;
36927 if (arg7 == NULL) {
36928 SWIG_null_ref("wxValidator");
36929 }
36930 if (SWIG_arg_fail(7)) SWIG_fail;
36931 }
36932 }
36933 if (obj7) {
36934 {
36935 arg8 = wxString_in_helper(obj7);
36936 if (arg8 == NULL) SWIG_fail;
36937 temp8 = true;
36938 }
36939 }
36940 {
36941 PyThreadState* __tstate = wxPyBeginAllowThreads();
36942 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36943
36944 wxPyEndAllowThreads(__tstate);
36945 if (PyErr_Occurred()) SWIG_fail;
36946 }
36947 {
36948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36949 }
36950 {
36951 if (temp8)
36952 delete arg8;
36953 }
36954 return resultobj;
36955 fail:
36956 {
36957 if (temp8)
36958 delete arg8;
36959 }
36960 return NULL;
36961 }
36962
36963
36964 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36965 PyObject *resultobj;
36966 wxControl *arg1 = (wxControl *) 0 ;
36967 wxCommandEvent *arg2 = 0 ;
36968 PyObject * obj0 = 0 ;
36969 PyObject * obj1 = 0 ;
36970 char *kwnames[] = {
36971 (char *) "self",(char *) "event", NULL
36972 };
36973
36974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36976 if (SWIG_arg_fail(1)) SWIG_fail;
36977 {
36978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36979 if (SWIG_arg_fail(2)) SWIG_fail;
36980 if (arg2 == NULL) {
36981 SWIG_null_ref("wxCommandEvent");
36982 }
36983 if (SWIG_arg_fail(2)) SWIG_fail;
36984 }
36985 {
36986 PyThreadState* __tstate = wxPyBeginAllowThreads();
36987 (arg1)->Command(*arg2);
36988
36989 wxPyEndAllowThreads(__tstate);
36990 if (PyErr_Occurred()) SWIG_fail;
36991 }
36992 Py_INCREF(Py_None); resultobj = Py_None;
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37000 PyObject *resultobj;
37001 wxControl *arg1 = (wxControl *) 0 ;
37002 wxString result;
37003 PyObject * obj0 = 0 ;
37004 char *kwnames[] = {
37005 (char *) "self", NULL
37006 };
37007
37008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37010 if (SWIG_arg_fail(1)) SWIG_fail;
37011 {
37012 PyThreadState* __tstate = wxPyBeginAllowThreads();
37013 result = (arg1)->GetLabel();
37014
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 {
37019 #if wxUSE_UNICODE
37020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37021 #else
37022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37023 #endif
37024 }
37025 return resultobj;
37026 fail:
37027 return NULL;
37028 }
37029
37030
37031 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37032 PyObject *resultobj;
37033 wxControl *arg1 = (wxControl *) 0 ;
37034 wxString *arg2 = 0 ;
37035 bool temp2 = false ;
37036 PyObject * obj0 = 0 ;
37037 PyObject * obj1 = 0 ;
37038 char *kwnames[] = {
37039 (char *) "self",(char *) "label", NULL
37040 };
37041
37042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37044 if (SWIG_arg_fail(1)) SWIG_fail;
37045 {
37046 arg2 = wxString_in_helper(obj1);
37047 if (arg2 == NULL) SWIG_fail;
37048 temp2 = true;
37049 }
37050 {
37051 PyThreadState* __tstate = wxPyBeginAllowThreads();
37052 (arg1)->SetLabel((wxString const &)*arg2);
37053
37054 wxPyEndAllowThreads(__tstate);
37055 if (PyErr_Occurred()) SWIG_fail;
37056 }
37057 Py_INCREF(Py_None); resultobj = Py_None;
37058 {
37059 if (temp2)
37060 delete arg2;
37061 }
37062 return resultobj;
37063 fail:
37064 {
37065 if (temp2)
37066 delete arg2;
37067 }
37068 return NULL;
37069 }
37070
37071
37072 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37073 PyObject *resultobj;
37074 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37075 wxVisualAttributes result;
37076 PyObject * obj0 = 0 ;
37077 char *kwnames[] = {
37078 (char *) "variant", NULL
37079 };
37080
37081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37082 if (obj0) {
37083 {
37084 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37085 if (SWIG_arg_fail(1)) SWIG_fail;
37086 }
37087 }
37088 {
37089 if (!wxPyCheckForApp()) SWIG_fail;
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37092
37093 wxPyEndAllowThreads(__tstate);
37094 if (PyErr_Occurred()) SWIG_fail;
37095 }
37096 {
37097 wxVisualAttributes * resultptr;
37098 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37100 }
37101 return resultobj;
37102 fail:
37103 return NULL;
37104 }
37105
37106
37107 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37108 PyObject *obj;
37109 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37110 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37111 Py_INCREF(obj);
37112 return Py_BuildValue((char *)"");
37113 }
37114 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37115 PyObject *resultobj;
37116 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37117 wxString *arg2 = 0 ;
37118 PyObject *arg3 = (PyObject *) NULL ;
37119 int result;
37120 bool temp2 = false ;
37121 PyObject * obj0 = 0 ;
37122 PyObject * obj1 = 0 ;
37123 PyObject * obj2 = 0 ;
37124 char *kwnames[] = {
37125 (char *) "self",(char *) "item",(char *) "clientData", NULL
37126 };
37127
37128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37130 if (SWIG_arg_fail(1)) SWIG_fail;
37131 {
37132 arg2 = wxString_in_helper(obj1);
37133 if (arg2 == NULL) SWIG_fail;
37134 temp2 = true;
37135 }
37136 if (obj2) {
37137 arg3 = obj2;
37138 }
37139 {
37140 PyThreadState* __tstate = wxPyBeginAllowThreads();
37141 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37142
37143 wxPyEndAllowThreads(__tstate);
37144 if (PyErr_Occurred()) SWIG_fail;
37145 }
37146 {
37147 resultobj = SWIG_From_int((int)(result));
37148 }
37149 {
37150 if (temp2)
37151 delete arg2;
37152 }
37153 return resultobj;
37154 fail:
37155 {
37156 if (temp2)
37157 delete arg2;
37158 }
37159 return NULL;
37160 }
37161
37162
37163 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37164 PyObject *resultobj;
37165 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37166 wxArrayString *arg2 = 0 ;
37167 bool temp2 = false ;
37168 PyObject * obj0 = 0 ;
37169 PyObject * obj1 = 0 ;
37170 char *kwnames[] = {
37171 (char *) "self",(char *) "strings", NULL
37172 };
37173
37174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37176 if (SWIG_arg_fail(1)) SWIG_fail;
37177 {
37178 if (! PySequence_Check(obj1)) {
37179 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37180 SWIG_fail;
37181 }
37182 arg2 = new wxArrayString;
37183 temp2 = true;
37184 int i, len=PySequence_Length(obj1);
37185 for (i=0; i<len; i++) {
37186 PyObject* item = PySequence_GetItem(obj1, i);
37187 #if wxUSE_UNICODE
37188 PyObject* str = PyObject_Unicode(item);
37189 #else
37190 PyObject* str = PyObject_Str(item);
37191 #endif
37192 if (PyErr_Occurred()) SWIG_fail;
37193 arg2->Add(Py2wxString(str));
37194 Py_DECREF(item);
37195 Py_DECREF(str);
37196 }
37197 }
37198 {
37199 PyThreadState* __tstate = wxPyBeginAllowThreads();
37200 (arg1)->Append((wxArrayString const &)*arg2);
37201
37202 wxPyEndAllowThreads(__tstate);
37203 if (PyErr_Occurred()) SWIG_fail;
37204 }
37205 Py_INCREF(Py_None); resultobj = Py_None;
37206 {
37207 if (temp2) delete arg2;
37208 }
37209 return resultobj;
37210 fail:
37211 {
37212 if (temp2) delete arg2;
37213 }
37214 return NULL;
37215 }
37216
37217
37218 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37219 PyObject *resultobj;
37220 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37221 wxString *arg2 = 0 ;
37222 int arg3 ;
37223 PyObject *arg4 = (PyObject *) NULL ;
37224 int result;
37225 bool temp2 = false ;
37226 PyObject * obj0 = 0 ;
37227 PyObject * obj1 = 0 ;
37228 PyObject * obj2 = 0 ;
37229 PyObject * obj3 = 0 ;
37230 char *kwnames[] = {
37231 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37232 };
37233
37234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37236 if (SWIG_arg_fail(1)) SWIG_fail;
37237 {
37238 arg2 = wxString_in_helper(obj1);
37239 if (arg2 == NULL) SWIG_fail;
37240 temp2 = true;
37241 }
37242 {
37243 arg3 = (int)(SWIG_As_int(obj2));
37244 if (SWIG_arg_fail(3)) SWIG_fail;
37245 }
37246 if (obj3) {
37247 arg4 = obj3;
37248 }
37249 {
37250 PyThreadState* __tstate = wxPyBeginAllowThreads();
37251 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37252
37253 wxPyEndAllowThreads(__tstate);
37254 if (PyErr_Occurred()) SWIG_fail;
37255 }
37256 {
37257 resultobj = SWIG_From_int((int)(result));
37258 }
37259 {
37260 if (temp2)
37261 delete arg2;
37262 }
37263 return resultobj;
37264 fail:
37265 {
37266 if (temp2)
37267 delete arg2;
37268 }
37269 return NULL;
37270 }
37271
37272
37273 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37274 PyObject *resultobj;
37275 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37276 PyObject * obj0 = 0 ;
37277 char *kwnames[] = {
37278 (char *) "self", NULL
37279 };
37280
37281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37283 if (SWIG_arg_fail(1)) SWIG_fail;
37284 {
37285 PyThreadState* __tstate = wxPyBeginAllowThreads();
37286 (arg1)->Clear();
37287
37288 wxPyEndAllowThreads(__tstate);
37289 if (PyErr_Occurred()) SWIG_fail;
37290 }
37291 Py_INCREF(Py_None); resultobj = Py_None;
37292 return resultobj;
37293 fail:
37294 return NULL;
37295 }
37296
37297
37298 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37299 PyObject *resultobj;
37300 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37301 int arg2 ;
37302 PyObject * obj0 = 0 ;
37303 PyObject * obj1 = 0 ;
37304 char *kwnames[] = {
37305 (char *) "self",(char *) "n", NULL
37306 };
37307
37308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37310 if (SWIG_arg_fail(1)) SWIG_fail;
37311 {
37312 arg2 = (int)(SWIG_As_int(obj1));
37313 if (SWIG_arg_fail(2)) SWIG_fail;
37314 }
37315 {
37316 PyThreadState* __tstate = wxPyBeginAllowThreads();
37317 (arg1)->Delete(arg2);
37318
37319 wxPyEndAllowThreads(__tstate);
37320 if (PyErr_Occurred()) SWIG_fail;
37321 }
37322 Py_INCREF(Py_None); resultobj = Py_None;
37323 return resultobj;
37324 fail:
37325 return NULL;
37326 }
37327
37328
37329 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37330 PyObject *resultobj;
37331 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37332 int arg2 ;
37333 PyObject *result;
37334 PyObject * obj0 = 0 ;
37335 PyObject * obj1 = 0 ;
37336 char *kwnames[] = {
37337 (char *) "self",(char *) "n", NULL
37338 };
37339
37340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37342 if (SWIG_arg_fail(1)) SWIG_fail;
37343 {
37344 arg2 = (int)(SWIG_As_int(obj1));
37345 if (SWIG_arg_fail(2)) SWIG_fail;
37346 }
37347 {
37348 PyThreadState* __tstate = wxPyBeginAllowThreads();
37349 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37350
37351 wxPyEndAllowThreads(__tstate);
37352 if (PyErr_Occurred()) SWIG_fail;
37353 }
37354 resultobj = result;
37355 return resultobj;
37356 fail:
37357 return NULL;
37358 }
37359
37360
37361 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37362 PyObject *resultobj;
37363 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37364 int arg2 ;
37365 PyObject *arg3 = (PyObject *) 0 ;
37366 PyObject * obj0 = 0 ;
37367 PyObject * obj1 = 0 ;
37368 PyObject * obj2 = 0 ;
37369 char *kwnames[] = {
37370 (char *) "self",(char *) "n",(char *) "clientData", NULL
37371 };
37372
37373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37375 if (SWIG_arg_fail(1)) SWIG_fail;
37376 {
37377 arg2 = (int)(SWIG_As_int(obj1));
37378 if (SWIG_arg_fail(2)) SWIG_fail;
37379 }
37380 arg3 = obj2;
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 wxItemContainer_SetClientData(arg1,arg2,arg3);
37384
37385 wxPyEndAllowThreads(__tstate);
37386 if (PyErr_Occurred()) SWIG_fail;
37387 }
37388 Py_INCREF(Py_None); resultobj = Py_None;
37389 return resultobj;
37390 fail:
37391 return NULL;
37392 }
37393
37394
37395 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37396 PyObject *resultobj;
37397 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37398 int result;
37399 PyObject * obj0 = 0 ;
37400 char *kwnames[] = {
37401 (char *) "self", NULL
37402 };
37403
37404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37406 if (SWIG_arg_fail(1)) SWIG_fail;
37407 {
37408 PyThreadState* __tstate = wxPyBeginAllowThreads();
37409 result = (int)((wxItemContainer const *)arg1)->GetCount();
37410
37411 wxPyEndAllowThreads(__tstate);
37412 if (PyErr_Occurred()) SWIG_fail;
37413 }
37414 {
37415 resultobj = SWIG_From_int((int)(result));
37416 }
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37424 PyObject *resultobj;
37425 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37426 bool result;
37427 PyObject * obj0 = 0 ;
37428 char *kwnames[] = {
37429 (char *) "self", NULL
37430 };
37431
37432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37434 if (SWIG_arg_fail(1)) SWIG_fail;
37435 {
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37438
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 {
37443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37444 }
37445 return resultobj;
37446 fail:
37447 return NULL;
37448 }
37449
37450
37451 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37452 PyObject *resultobj;
37453 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37454 int arg2 ;
37455 wxString result;
37456 PyObject * obj0 = 0 ;
37457 PyObject * obj1 = 0 ;
37458 char *kwnames[] = {
37459 (char *) "self",(char *) "n", NULL
37460 };
37461
37462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37464 if (SWIG_arg_fail(1)) SWIG_fail;
37465 {
37466 arg2 = (int)(SWIG_As_int(obj1));
37467 if (SWIG_arg_fail(2)) SWIG_fail;
37468 }
37469 {
37470 PyThreadState* __tstate = wxPyBeginAllowThreads();
37471 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37472
37473 wxPyEndAllowThreads(__tstate);
37474 if (PyErr_Occurred()) SWIG_fail;
37475 }
37476 {
37477 #if wxUSE_UNICODE
37478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37479 #else
37480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37481 #endif
37482 }
37483 return resultobj;
37484 fail:
37485 return NULL;
37486 }
37487
37488
37489 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37490 PyObject *resultobj;
37491 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37492 wxArrayString result;
37493 PyObject * obj0 = 0 ;
37494 char *kwnames[] = {
37495 (char *) "self", NULL
37496 };
37497
37498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37500 if (SWIG_arg_fail(1)) SWIG_fail;
37501 {
37502 PyThreadState* __tstate = wxPyBeginAllowThreads();
37503 result = ((wxItemContainer const *)arg1)->GetStrings();
37504
37505 wxPyEndAllowThreads(__tstate);
37506 if (PyErr_Occurred()) SWIG_fail;
37507 }
37508 {
37509 resultobj = wxArrayString2PyList_helper(result);
37510 }
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj;
37519 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37520 int arg2 ;
37521 wxString *arg3 = 0 ;
37522 bool temp3 = false ;
37523 PyObject * obj0 = 0 ;
37524 PyObject * obj1 = 0 ;
37525 PyObject * obj2 = 0 ;
37526 char *kwnames[] = {
37527 (char *) "self",(char *) "n",(char *) "s", NULL
37528 };
37529
37530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37532 if (SWIG_arg_fail(1)) SWIG_fail;
37533 {
37534 arg2 = (int)(SWIG_As_int(obj1));
37535 if (SWIG_arg_fail(2)) SWIG_fail;
37536 }
37537 {
37538 arg3 = wxString_in_helper(obj2);
37539 if (arg3 == NULL) SWIG_fail;
37540 temp3 = true;
37541 }
37542 {
37543 PyThreadState* __tstate = wxPyBeginAllowThreads();
37544 (arg1)->SetString(arg2,(wxString const &)*arg3);
37545
37546 wxPyEndAllowThreads(__tstate);
37547 if (PyErr_Occurred()) SWIG_fail;
37548 }
37549 Py_INCREF(Py_None); resultobj = Py_None;
37550 {
37551 if (temp3)
37552 delete arg3;
37553 }
37554 return resultobj;
37555 fail:
37556 {
37557 if (temp3)
37558 delete arg3;
37559 }
37560 return NULL;
37561 }
37562
37563
37564 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37565 PyObject *resultobj;
37566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37567 wxString *arg2 = 0 ;
37568 int result;
37569 bool temp2 = false ;
37570 PyObject * obj0 = 0 ;
37571 PyObject * obj1 = 0 ;
37572 char *kwnames[] = {
37573 (char *) "self",(char *) "s", NULL
37574 };
37575
37576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37578 if (SWIG_arg_fail(1)) SWIG_fail;
37579 {
37580 arg2 = wxString_in_helper(obj1);
37581 if (arg2 == NULL) SWIG_fail;
37582 temp2 = true;
37583 }
37584 {
37585 PyThreadState* __tstate = wxPyBeginAllowThreads();
37586 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37587
37588 wxPyEndAllowThreads(__tstate);
37589 if (PyErr_Occurred()) SWIG_fail;
37590 }
37591 {
37592 resultobj = SWIG_From_int((int)(result));
37593 }
37594 {
37595 if (temp2)
37596 delete arg2;
37597 }
37598 return resultobj;
37599 fail:
37600 {
37601 if (temp2)
37602 delete arg2;
37603 }
37604 return NULL;
37605 }
37606
37607
37608 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37609 PyObject *resultobj;
37610 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37611 int arg2 ;
37612 PyObject * obj0 = 0 ;
37613 PyObject * obj1 = 0 ;
37614 char *kwnames[] = {
37615 (char *) "self",(char *) "n", NULL
37616 };
37617
37618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37620 if (SWIG_arg_fail(1)) SWIG_fail;
37621 {
37622 arg2 = (int)(SWIG_As_int(obj1));
37623 if (SWIG_arg_fail(2)) SWIG_fail;
37624 }
37625 {
37626 PyThreadState* __tstate = wxPyBeginAllowThreads();
37627 (arg1)->SetSelection(arg2);
37628
37629 wxPyEndAllowThreads(__tstate);
37630 if (PyErr_Occurred()) SWIG_fail;
37631 }
37632 Py_INCREF(Py_None); resultobj = Py_None;
37633 return resultobj;
37634 fail:
37635 return NULL;
37636 }
37637
37638
37639 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37640 PyObject *resultobj;
37641 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37642 int result;
37643 PyObject * obj0 = 0 ;
37644 char *kwnames[] = {
37645 (char *) "self", NULL
37646 };
37647
37648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37650 if (SWIG_arg_fail(1)) SWIG_fail;
37651 {
37652 PyThreadState* __tstate = wxPyBeginAllowThreads();
37653 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37654
37655 wxPyEndAllowThreads(__tstate);
37656 if (PyErr_Occurred()) SWIG_fail;
37657 }
37658 {
37659 resultobj = SWIG_From_int((int)(result));
37660 }
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37668 PyObject *resultobj;
37669 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37670 wxString *arg2 = 0 ;
37671 bool result;
37672 bool temp2 = false ;
37673 PyObject * obj0 = 0 ;
37674 PyObject * obj1 = 0 ;
37675 char *kwnames[] = {
37676 (char *) "self",(char *) "s", NULL
37677 };
37678
37679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37681 if (SWIG_arg_fail(1)) SWIG_fail;
37682 {
37683 arg2 = wxString_in_helper(obj1);
37684 if (arg2 == NULL) SWIG_fail;
37685 temp2 = true;
37686 }
37687 {
37688 PyThreadState* __tstate = wxPyBeginAllowThreads();
37689 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37690
37691 wxPyEndAllowThreads(__tstate);
37692 if (PyErr_Occurred()) SWIG_fail;
37693 }
37694 {
37695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37696 }
37697 {
37698 if (temp2)
37699 delete arg2;
37700 }
37701 return resultobj;
37702 fail:
37703 {
37704 if (temp2)
37705 delete arg2;
37706 }
37707 return NULL;
37708 }
37709
37710
37711 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37712 PyObject *resultobj;
37713 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37714 wxString result;
37715 PyObject * obj0 = 0 ;
37716 char *kwnames[] = {
37717 (char *) "self", NULL
37718 };
37719
37720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37722 if (SWIG_arg_fail(1)) SWIG_fail;
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37726
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 {
37731 #if wxUSE_UNICODE
37732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37733 #else
37734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37735 #endif
37736 }
37737 return resultobj;
37738 fail:
37739 return NULL;
37740 }
37741
37742
37743 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37744 PyObject *resultobj;
37745 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37746 int arg2 ;
37747 PyObject * obj0 = 0 ;
37748 PyObject * obj1 = 0 ;
37749 char *kwnames[] = {
37750 (char *) "self",(char *) "n", NULL
37751 };
37752
37753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37755 if (SWIG_arg_fail(1)) SWIG_fail;
37756 {
37757 arg2 = (int)(SWIG_As_int(obj1));
37758 if (SWIG_arg_fail(2)) SWIG_fail;
37759 }
37760 {
37761 PyThreadState* __tstate = wxPyBeginAllowThreads();
37762 (arg1)->Select(arg2);
37763
37764 wxPyEndAllowThreads(__tstate);
37765 if (PyErr_Occurred()) SWIG_fail;
37766 }
37767 Py_INCREF(Py_None); resultobj = Py_None;
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37775 PyObject *obj;
37776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37777 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37778 Py_INCREF(obj);
37779 return Py_BuildValue((char *)"");
37780 }
37781 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37782 PyObject *obj;
37783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37784 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37785 Py_INCREF(obj);
37786 return Py_BuildValue((char *)"");
37787 }
37788 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37789 PyObject *resultobj;
37790 wxSizerItem *result;
37791 char *kwnames[] = {
37792 NULL
37793 };
37794
37795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37796 {
37797 PyThreadState* __tstate = wxPyBeginAllowThreads();
37798 result = (wxSizerItem *)new wxSizerItem();
37799
37800 wxPyEndAllowThreads(__tstate);
37801 if (PyErr_Occurred()) SWIG_fail;
37802 }
37803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37804 return resultobj;
37805 fail:
37806 return NULL;
37807 }
37808
37809
37810 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37811 PyObject *resultobj;
37812 wxWindow *arg1 = (wxWindow *) 0 ;
37813 int arg2 ;
37814 int arg3 ;
37815 int arg4 ;
37816 PyObject *arg5 = (PyObject *) NULL ;
37817 wxSizerItem *result;
37818 PyObject * obj0 = 0 ;
37819 PyObject * obj1 = 0 ;
37820 PyObject * obj2 = 0 ;
37821 PyObject * obj3 = 0 ;
37822 PyObject * obj4 = 0 ;
37823 char *kwnames[] = {
37824 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37825 };
37826
37827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37829 if (SWIG_arg_fail(1)) SWIG_fail;
37830 {
37831 arg2 = (int)(SWIG_As_int(obj1));
37832 if (SWIG_arg_fail(2)) SWIG_fail;
37833 }
37834 {
37835 arg3 = (int)(SWIG_As_int(obj2));
37836 if (SWIG_arg_fail(3)) SWIG_fail;
37837 }
37838 {
37839 arg4 = (int)(SWIG_As_int(obj3));
37840 if (SWIG_arg_fail(4)) SWIG_fail;
37841 }
37842 if (obj4) {
37843 arg5 = obj4;
37844 }
37845 {
37846 PyThreadState* __tstate = wxPyBeginAllowThreads();
37847 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37848
37849 wxPyEndAllowThreads(__tstate);
37850 if (PyErr_Occurred()) SWIG_fail;
37851 }
37852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37853 return resultobj;
37854 fail:
37855 return NULL;
37856 }
37857
37858
37859 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37860 PyObject *resultobj;
37861 int arg1 ;
37862 int arg2 ;
37863 int arg3 ;
37864 int arg4 ;
37865 int arg5 ;
37866 PyObject *arg6 = (PyObject *) NULL ;
37867 wxSizerItem *result;
37868 PyObject * obj0 = 0 ;
37869 PyObject * obj1 = 0 ;
37870 PyObject * obj2 = 0 ;
37871 PyObject * obj3 = 0 ;
37872 PyObject * obj4 = 0 ;
37873 PyObject * obj5 = 0 ;
37874 char *kwnames[] = {
37875 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37876 };
37877
37878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37879 {
37880 arg1 = (int)(SWIG_As_int(obj0));
37881 if (SWIG_arg_fail(1)) SWIG_fail;
37882 }
37883 {
37884 arg2 = (int)(SWIG_As_int(obj1));
37885 if (SWIG_arg_fail(2)) SWIG_fail;
37886 }
37887 {
37888 arg3 = (int)(SWIG_As_int(obj2));
37889 if (SWIG_arg_fail(3)) SWIG_fail;
37890 }
37891 {
37892 arg4 = (int)(SWIG_As_int(obj3));
37893 if (SWIG_arg_fail(4)) SWIG_fail;
37894 }
37895 {
37896 arg5 = (int)(SWIG_As_int(obj4));
37897 if (SWIG_arg_fail(5)) SWIG_fail;
37898 }
37899 if (obj5) {
37900 arg6 = obj5;
37901 }
37902 {
37903 PyThreadState* __tstate = wxPyBeginAllowThreads();
37904 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37905
37906 wxPyEndAllowThreads(__tstate);
37907 if (PyErr_Occurred()) SWIG_fail;
37908 }
37909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37910 return resultobj;
37911 fail:
37912 return NULL;
37913 }
37914
37915
37916 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37917 PyObject *resultobj;
37918 wxSizer *arg1 = (wxSizer *) 0 ;
37919 int arg2 ;
37920 int arg3 ;
37921 int arg4 ;
37922 PyObject *arg5 = (PyObject *) NULL ;
37923 wxSizerItem *result;
37924 PyObject * obj0 = 0 ;
37925 PyObject * obj1 = 0 ;
37926 PyObject * obj2 = 0 ;
37927 PyObject * obj3 = 0 ;
37928 PyObject * obj4 = 0 ;
37929 char *kwnames[] = {
37930 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37931 };
37932
37933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37935 if (SWIG_arg_fail(1)) SWIG_fail;
37936 {
37937 arg2 = (int)(SWIG_As_int(obj1));
37938 if (SWIG_arg_fail(2)) SWIG_fail;
37939 }
37940 {
37941 arg3 = (int)(SWIG_As_int(obj2));
37942 if (SWIG_arg_fail(3)) SWIG_fail;
37943 }
37944 {
37945 arg4 = (int)(SWIG_As_int(obj3));
37946 if (SWIG_arg_fail(4)) SWIG_fail;
37947 }
37948 if (obj4) {
37949 arg5 = obj4;
37950 }
37951 {
37952 PyThreadState* __tstate = wxPyBeginAllowThreads();
37953 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37954
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37959 return resultobj;
37960 fail:
37961 return NULL;
37962 }
37963
37964
37965 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37966 PyObject *resultobj;
37967 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37968 PyObject * obj0 = 0 ;
37969 char *kwnames[] = {
37970 (char *) "self", NULL
37971 };
37972
37973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37975 if (SWIG_arg_fail(1)) SWIG_fail;
37976 {
37977 PyThreadState* __tstate = wxPyBeginAllowThreads();
37978 (arg1)->DeleteWindows();
37979
37980 wxPyEndAllowThreads(__tstate);
37981 if (PyErr_Occurred()) SWIG_fail;
37982 }
37983 Py_INCREF(Py_None); resultobj = Py_None;
37984 return resultobj;
37985 fail:
37986 return NULL;
37987 }
37988
37989
37990 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37991 PyObject *resultobj;
37992 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37993 PyObject * obj0 = 0 ;
37994 char *kwnames[] = {
37995 (char *) "self", NULL
37996 };
37997
37998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38000 if (SWIG_arg_fail(1)) SWIG_fail;
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 (arg1)->DetachSizer();
38004
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 Py_INCREF(Py_None); resultobj = Py_None;
38009 return resultobj;
38010 fail:
38011 return NULL;
38012 }
38013
38014
38015 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38016 PyObject *resultobj;
38017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38018 wxSize result;
38019 PyObject * obj0 = 0 ;
38020 char *kwnames[] = {
38021 (char *) "self", NULL
38022 };
38023
38024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38026 if (SWIG_arg_fail(1)) SWIG_fail;
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 result = (arg1)->GetSize();
38030
38031 wxPyEndAllowThreads(__tstate);
38032 if (PyErr_Occurred()) SWIG_fail;
38033 }
38034 {
38035 wxSize * resultptr;
38036 resultptr = new wxSize((wxSize &)(result));
38037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38038 }
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38046 PyObject *resultobj;
38047 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38048 wxSize result;
38049 PyObject * obj0 = 0 ;
38050 char *kwnames[] = {
38051 (char *) "self", NULL
38052 };
38053
38054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38056 if (SWIG_arg_fail(1)) SWIG_fail;
38057 {
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 result = (arg1)->CalcMin();
38060
38061 wxPyEndAllowThreads(__tstate);
38062 if (PyErr_Occurred()) SWIG_fail;
38063 }
38064 {
38065 wxSize * resultptr;
38066 resultptr = new wxSize((wxSize &)(result));
38067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38068 }
38069 return resultobj;
38070 fail:
38071 return NULL;
38072 }
38073
38074
38075 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38076 PyObject *resultobj;
38077 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38078 wxPoint arg2 ;
38079 wxSize arg3 ;
38080 PyObject * obj0 = 0 ;
38081 PyObject * obj1 = 0 ;
38082 PyObject * obj2 = 0 ;
38083 char *kwnames[] = {
38084 (char *) "self",(char *) "pos",(char *) "size", NULL
38085 };
38086
38087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38089 if (SWIG_arg_fail(1)) SWIG_fail;
38090 {
38091 wxPoint * argp;
38092 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38093 if (SWIG_arg_fail(2)) SWIG_fail;
38094 if (argp == NULL) {
38095 SWIG_null_ref("wxPoint");
38096 }
38097 if (SWIG_arg_fail(2)) SWIG_fail;
38098 arg2 = *argp;
38099 }
38100 {
38101 wxSize * argp;
38102 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38103 if (SWIG_arg_fail(3)) SWIG_fail;
38104 if (argp == NULL) {
38105 SWIG_null_ref("wxSize");
38106 }
38107 if (SWIG_arg_fail(3)) SWIG_fail;
38108 arg3 = *argp;
38109 }
38110 {
38111 PyThreadState* __tstate = wxPyBeginAllowThreads();
38112 (arg1)->SetDimension(arg2,arg3);
38113
38114 wxPyEndAllowThreads(__tstate);
38115 if (PyErr_Occurred()) SWIG_fail;
38116 }
38117 Py_INCREF(Py_None); resultobj = Py_None;
38118 return resultobj;
38119 fail:
38120 return NULL;
38121 }
38122
38123
38124 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38125 PyObject *resultobj;
38126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38127 wxSize result;
38128 PyObject * obj0 = 0 ;
38129 char *kwnames[] = {
38130 (char *) "self", NULL
38131 };
38132
38133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38135 if (SWIG_arg_fail(1)) SWIG_fail;
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 result = (arg1)->GetMinSize();
38139
38140 wxPyEndAllowThreads(__tstate);
38141 if (PyErr_Occurred()) SWIG_fail;
38142 }
38143 {
38144 wxSize * resultptr;
38145 resultptr = new wxSize((wxSize &)(result));
38146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38147 }
38148 return resultobj;
38149 fail:
38150 return NULL;
38151 }
38152
38153
38154 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38155 PyObject *resultobj;
38156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38157 wxSize result;
38158 PyObject * obj0 = 0 ;
38159 char *kwnames[] = {
38160 (char *) "self", NULL
38161 };
38162
38163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38165 if (SWIG_arg_fail(1)) SWIG_fail;
38166 {
38167 PyThreadState* __tstate = wxPyBeginAllowThreads();
38168 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38169
38170 wxPyEndAllowThreads(__tstate);
38171 if (PyErr_Occurred()) SWIG_fail;
38172 }
38173 {
38174 wxSize * resultptr;
38175 resultptr = new wxSize((wxSize &)(result));
38176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38177 }
38178 return resultobj;
38179 fail:
38180 return NULL;
38181 }
38182
38183
38184 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38185 PyObject *resultobj;
38186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38187 int arg2 ;
38188 int arg3 ;
38189 PyObject * obj0 = 0 ;
38190 PyObject * obj1 = 0 ;
38191 PyObject * obj2 = 0 ;
38192 char *kwnames[] = {
38193 (char *) "self",(char *) "x",(char *) "y", NULL
38194 };
38195
38196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38198 if (SWIG_arg_fail(1)) SWIG_fail;
38199 {
38200 arg2 = (int)(SWIG_As_int(obj1));
38201 if (SWIG_arg_fail(2)) SWIG_fail;
38202 }
38203 {
38204 arg3 = (int)(SWIG_As_int(obj2));
38205 if (SWIG_arg_fail(3)) SWIG_fail;
38206 }
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 (arg1)->SetInitSize(arg2,arg3);
38210
38211 wxPyEndAllowThreads(__tstate);
38212 if (PyErr_Occurred()) SWIG_fail;
38213 }
38214 Py_INCREF(Py_None); resultobj = Py_None;
38215 return resultobj;
38216 fail:
38217 return NULL;
38218 }
38219
38220
38221 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38222 PyObject *resultobj;
38223 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38224 int arg2 ;
38225 int arg3 ;
38226 PyObject * obj0 = 0 ;
38227 PyObject * obj1 = 0 ;
38228 PyObject * obj2 = 0 ;
38229 char *kwnames[] = {
38230 (char *) "self",(char *) "width",(char *) "height", NULL
38231 };
38232
38233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38235 if (SWIG_arg_fail(1)) SWIG_fail;
38236 {
38237 arg2 = (int)(SWIG_As_int(obj1));
38238 if (SWIG_arg_fail(2)) SWIG_fail;
38239 }
38240 {
38241 arg3 = (int)(SWIG_As_int(obj2));
38242 if (SWIG_arg_fail(3)) SWIG_fail;
38243 }
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 (arg1)->SetRatio(arg2,arg3);
38247
38248 wxPyEndAllowThreads(__tstate);
38249 if (PyErr_Occurred()) SWIG_fail;
38250 }
38251 Py_INCREF(Py_None); resultobj = Py_None;
38252 return resultobj;
38253 fail:
38254 return NULL;
38255 }
38256
38257
38258 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38259 PyObject *resultobj;
38260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38261 wxSize arg2 ;
38262 PyObject * obj0 = 0 ;
38263 PyObject * obj1 = 0 ;
38264 char *kwnames[] = {
38265 (char *) "self",(char *) "size", NULL
38266 };
38267
38268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38270 if (SWIG_arg_fail(1)) SWIG_fail;
38271 {
38272 wxSize * argp;
38273 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38274 if (SWIG_arg_fail(2)) SWIG_fail;
38275 if (argp == NULL) {
38276 SWIG_null_ref("wxSize");
38277 }
38278 if (SWIG_arg_fail(2)) SWIG_fail;
38279 arg2 = *argp;
38280 }
38281 {
38282 PyThreadState* __tstate = wxPyBeginAllowThreads();
38283 (arg1)->SetRatio(arg2);
38284
38285 wxPyEndAllowThreads(__tstate);
38286 if (PyErr_Occurred()) SWIG_fail;
38287 }
38288 Py_INCREF(Py_None); resultobj = Py_None;
38289 return resultobj;
38290 fail:
38291 return NULL;
38292 }
38293
38294
38295 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38296 PyObject *resultobj;
38297 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38298 float arg2 ;
38299 PyObject * obj0 = 0 ;
38300 PyObject * obj1 = 0 ;
38301 char *kwnames[] = {
38302 (char *) "self",(char *) "ratio", NULL
38303 };
38304
38305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38307 if (SWIG_arg_fail(1)) SWIG_fail;
38308 {
38309 arg2 = (float)(SWIG_As_float(obj1));
38310 if (SWIG_arg_fail(2)) SWIG_fail;
38311 }
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 (arg1)->SetRatio(arg2);
38315
38316 wxPyEndAllowThreads(__tstate);
38317 if (PyErr_Occurred()) SWIG_fail;
38318 }
38319 Py_INCREF(Py_None); resultobj = Py_None;
38320 return resultobj;
38321 fail:
38322 return NULL;
38323 }
38324
38325
38326 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38327 PyObject *resultobj;
38328 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38329 float result;
38330 PyObject * obj0 = 0 ;
38331 char *kwnames[] = {
38332 (char *) "self", NULL
38333 };
38334
38335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38337 if (SWIG_arg_fail(1)) SWIG_fail;
38338 {
38339 PyThreadState* __tstate = wxPyBeginAllowThreads();
38340 result = (float)(arg1)->GetRatio();
38341
38342 wxPyEndAllowThreads(__tstate);
38343 if (PyErr_Occurred()) SWIG_fail;
38344 }
38345 {
38346 resultobj = SWIG_From_float((float)(result));
38347 }
38348 return resultobj;
38349 fail:
38350 return NULL;
38351 }
38352
38353
38354 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38355 PyObject *resultobj;
38356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38357 wxRect result;
38358 PyObject * obj0 = 0 ;
38359 char *kwnames[] = {
38360 (char *) "self", NULL
38361 };
38362
38363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38365 if (SWIG_arg_fail(1)) SWIG_fail;
38366 {
38367 PyThreadState* __tstate = wxPyBeginAllowThreads();
38368 result = (arg1)->GetRect();
38369
38370 wxPyEndAllowThreads(__tstate);
38371 if (PyErr_Occurred()) SWIG_fail;
38372 }
38373 {
38374 wxRect * resultptr;
38375 resultptr = new wxRect((wxRect &)(result));
38376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38377 }
38378 return resultobj;
38379 fail:
38380 return NULL;
38381 }
38382
38383
38384 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38385 PyObject *resultobj;
38386 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38387 bool result;
38388 PyObject * obj0 = 0 ;
38389 char *kwnames[] = {
38390 (char *) "self", NULL
38391 };
38392
38393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38395 if (SWIG_arg_fail(1)) SWIG_fail;
38396 {
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 result = (bool)(arg1)->IsWindow();
38399
38400 wxPyEndAllowThreads(__tstate);
38401 if (PyErr_Occurred()) SWIG_fail;
38402 }
38403 {
38404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38405 }
38406 return resultobj;
38407 fail:
38408 return NULL;
38409 }
38410
38411
38412 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38413 PyObject *resultobj;
38414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38415 bool result;
38416 PyObject * obj0 = 0 ;
38417 char *kwnames[] = {
38418 (char *) "self", NULL
38419 };
38420
38421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38423 if (SWIG_arg_fail(1)) SWIG_fail;
38424 {
38425 PyThreadState* __tstate = wxPyBeginAllowThreads();
38426 result = (bool)(arg1)->IsSizer();
38427
38428 wxPyEndAllowThreads(__tstate);
38429 if (PyErr_Occurred()) SWIG_fail;
38430 }
38431 {
38432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38433 }
38434 return resultobj;
38435 fail:
38436 return NULL;
38437 }
38438
38439
38440 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38441 PyObject *resultobj;
38442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38443 bool result;
38444 PyObject * obj0 = 0 ;
38445 char *kwnames[] = {
38446 (char *) "self", NULL
38447 };
38448
38449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38451 if (SWIG_arg_fail(1)) SWIG_fail;
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 result = (bool)(arg1)->IsSpacer();
38455
38456 wxPyEndAllowThreads(__tstate);
38457 if (PyErr_Occurred()) SWIG_fail;
38458 }
38459 {
38460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38461 }
38462 return resultobj;
38463 fail:
38464 return NULL;
38465 }
38466
38467
38468 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38469 PyObject *resultobj;
38470 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38471 int arg2 ;
38472 PyObject * obj0 = 0 ;
38473 PyObject * obj1 = 0 ;
38474 char *kwnames[] = {
38475 (char *) "self",(char *) "proportion", NULL
38476 };
38477
38478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38480 if (SWIG_arg_fail(1)) SWIG_fail;
38481 {
38482 arg2 = (int)(SWIG_As_int(obj1));
38483 if (SWIG_arg_fail(2)) SWIG_fail;
38484 }
38485 {
38486 PyThreadState* __tstate = wxPyBeginAllowThreads();
38487 (arg1)->SetProportion(arg2);
38488
38489 wxPyEndAllowThreads(__tstate);
38490 if (PyErr_Occurred()) SWIG_fail;
38491 }
38492 Py_INCREF(Py_None); resultobj = Py_None;
38493 return resultobj;
38494 fail:
38495 return NULL;
38496 }
38497
38498
38499 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38500 PyObject *resultobj;
38501 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38502 int result;
38503 PyObject * obj0 = 0 ;
38504 char *kwnames[] = {
38505 (char *) "self", NULL
38506 };
38507
38508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38510 if (SWIG_arg_fail(1)) SWIG_fail;
38511 {
38512 PyThreadState* __tstate = wxPyBeginAllowThreads();
38513 result = (int)(arg1)->GetProportion();
38514
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 {
38519 resultobj = SWIG_From_int((int)(result));
38520 }
38521 return resultobj;
38522 fail:
38523 return NULL;
38524 }
38525
38526
38527 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38528 PyObject *resultobj;
38529 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38530 int arg2 ;
38531 PyObject * obj0 = 0 ;
38532 PyObject * obj1 = 0 ;
38533 char *kwnames[] = {
38534 (char *) "self",(char *) "flag", NULL
38535 };
38536
38537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38539 if (SWIG_arg_fail(1)) SWIG_fail;
38540 {
38541 arg2 = (int)(SWIG_As_int(obj1));
38542 if (SWIG_arg_fail(2)) SWIG_fail;
38543 }
38544 {
38545 PyThreadState* __tstate = wxPyBeginAllowThreads();
38546 (arg1)->SetFlag(arg2);
38547
38548 wxPyEndAllowThreads(__tstate);
38549 if (PyErr_Occurred()) SWIG_fail;
38550 }
38551 Py_INCREF(Py_None); resultobj = Py_None;
38552 return resultobj;
38553 fail:
38554 return NULL;
38555 }
38556
38557
38558 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38559 PyObject *resultobj;
38560 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38561 int result;
38562 PyObject * obj0 = 0 ;
38563 char *kwnames[] = {
38564 (char *) "self", NULL
38565 };
38566
38567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38569 if (SWIG_arg_fail(1)) SWIG_fail;
38570 {
38571 PyThreadState* __tstate = wxPyBeginAllowThreads();
38572 result = (int)(arg1)->GetFlag();
38573
38574 wxPyEndAllowThreads(__tstate);
38575 if (PyErr_Occurred()) SWIG_fail;
38576 }
38577 {
38578 resultobj = SWIG_From_int((int)(result));
38579 }
38580 return resultobj;
38581 fail:
38582 return NULL;
38583 }
38584
38585
38586 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38587 PyObject *resultobj;
38588 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38589 int arg2 ;
38590 PyObject * obj0 = 0 ;
38591 PyObject * obj1 = 0 ;
38592 char *kwnames[] = {
38593 (char *) "self",(char *) "border", NULL
38594 };
38595
38596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38598 if (SWIG_arg_fail(1)) SWIG_fail;
38599 {
38600 arg2 = (int)(SWIG_As_int(obj1));
38601 if (SWIG_arg_fail(2)) SWIG_fail;
38602 }
38603 {
38604 PyThreadState* __tstate = wxPyBeginAllowThreads();
38605 (arg1)->SetBorder(arg2);
38606
38607 wxPyEndAllowThreads(__tstate);
38608 if (PyErr_Occurred()) SWIG_fail;
38609 }
38610 Py_INCREF(Py_None); resultobj = Py_None;
38611 return resultobj;
38612 fail:
38613 return NULL;
38614 }
38615
38616
38617 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38618 PyObject *resultobj;
38619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38620 int result;
38621 PyObject * obj0 = 0 ;
38622 char *kwnames[] = {
38623 (char *) "self", NULL
38624 };
38625
38626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38628 if (SWIG_arg_fail(1)) SWIG_fail;
38629 {
38630 PyThreadState* __tstate = wxPyBeginAllowThreads();
38631 result = (int)(arg1)->GetBorder();
38632
38633 wxPyEndAllowThreads(__tstate);
38634 if (PyErr_Occurred()) SWIG_fail;
38635 }
38636 {
38637 resultobj = SWIG_From_int((int)(result));
38638 }
38639 return resultobj;
38640 fail:
38641 return NULL;
38642 }
38643
38644
38645 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38646 PyObject *resultobj;
38647 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38648 wxWindow *result;
38649 PyObject * obj0 = 0 ;
38650 char *kwnames[] = {
38651 (char *) "self", NULL
38652 };
38653
38654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38656 if (SWIG_arg_fail(1)) SWIG_fail;
38657 {
38658 PyThreadState* __tstate = wxPyBeginAllowThreads();
38659 result = (wxWindow *)(arg1)->GetWindow();
38660
38661 wxPyEndAllowThreads(__tstate);
38662 if (PyErr_Occurred()) SWIG_fail;
38663 }
38664 {
38665 resultobj = wxPyMake_wxObject(result, 0);
38666 }
38667 return resultobj;
38668 fail:
38669 return NULL;
38670 }
38671
38672
38673 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38674 PyObject *resultobj;
38675 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38676 wxWindow *arg2 = (wxWindow *) 0 ;
38677 PyObject * obj0 = 0 ;
38678 PyObject * obj1 = 0 ;
38679 char *kwnames[] = {
38680 (char *) "self",(char *) "window", NULL
38681 };
38682
38683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38685 if (SWIG_arg_fail(1)) SWIG_fail;
38686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38687 if (SWIG_arg_fail(2)) SWIG_fail;
38688 {
38689 PyThreadState* __tstate = wxPyBeginAllowThreads();
38690 (arg1)->SetWindow(arg2);
38691
38692 wxPyEndAllowThreads(__tstate);
38693 if (PyErr_Occurred()) SWIG_fail;
38694 }
38695 Py_INCREF(Py_None); resultobj = Py_None;
38696 return resultobj;
38697 fail:
38698 return NULL;
38699 }
38700
38701
38702 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38703 PyObject *resultobj;
38704 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38705 wxSizer *result;
38706 PyObject * obj0 = 0 ;
38707 char *kwnames[] = {
38708 (char *) "self", NULL
38709 };
38710
38711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38713 if (SWIG_arg_fail(1)) SWIG_fail;
38714 {
38715 PyThreadState* __tstate = wxPyBeginAllowThreads();
38716 result = (wxSizer *)(arg1)->GetSizer();
38717
38718 wxPyEndAllowThreads(__tstate);
38719 if (PyErr_Occurred()) SWIG_fail;
38720 }
38721 {
38722 resultobj = wxPyMake_wxSizer(result, 0);
38723 }
38724 return resultobj;
38725 fail:
38726 return NULL;
38727 }
38728
38729
38730 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38731 PyObject *resultobj;
38732 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38733 wxSizer *arg2 = (wxSizer *) 0 ;
38734 PyObject * obj0 = 0 ;
38735 PyObject * obj1 = 0 ;
38736 char *kwnames[] = {
38737 (char *) "self",(char *) "sizer", NULL
38738 };
38739
38740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38742 if (SWIG_arg_fail(1)) SWIG_fail;
38743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38744 if (SWIG_arg_fail(2)) SWIG_fail;
38745 {
38746 PyThreadState* __tstate = wxPyBeginAllowThreads();
38747 (arg1)->SetSizer(arg2);
38748
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 Py_INCREF(Py_None); resultobj = Py_None;
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38760 PyObject *resultobj;
38761 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38762 wxSize *result;
38763 PyObject * obj0 = 0 ;
38764 char *kwnames[] = {
38765 (char *) "self", NULL
38766 };
38767
38768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38770 if (SWIG_arg_fail(1)) SWIG_fail;
38771 {
38772 PyThreadState* __tstate = wxPyBeginAllowThreads();
38773 {
38774 wxSize const &_result_ref = (arg1)->GetSpacer();
38775 result = (wxSize *) &_result_ref;
38776 }
38777
38778 wxPyEndAllowThreads(__tstate);
38779 if (PyErr_Occurred()) SWIG_fail;
38780 }
38781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38782 return resultobj;
38783 fail:
38784 return NULL;
38785 }
38786
38787
38788 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38789 PyObject *resultobj;
38790 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38791 wxSize *arg2 = 0 ;
38792 wxSize temp2 ;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 char *kwnames[] = {
38796 (char *) "self",(char *) "size", NULL
38797 };
38798
38799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38801 if (SWIG_arg_fail(1)) SWIG_fail;
38802 {
38803 arg2 = &temp2;
38804 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38805 }
38806 {
38807 PyThreadState* __tstate = wxPyBeginAllowThreads();
38808 (arg1)->SetSpacer((wxSize const &)*arg2);
38809
38810 wxPyEndAllowThreads(__tstate);
38811 if (PyErr_Occurred()) SWIG_fail;
38812 }
38813 Py_INCREF(Py_None); resultobj = Py_None;
38814 return resultobj;
38815 fail:
38816 return NULL;
38817 }
38818
38819
38820 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38821 PyObject *resultobj;
38822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38823 bool arg2 ;
38824 PyObject * obj0 = 0 ;
38825 PyObject * obj1 = 0 ;
38826 char *kwnames[] = {
38827 (char *) "self",(char *) "show", NULL
38828 };
38829
38830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38832 if (SWIG_arg_fail(1)) SWIG_fail;
38833 {
38834 arg2 = (bool)(SWIG_As_bool(obj1));
38835 if (SWIG_arg_fail(2)) SWIG_fail;
38836 }
38837 {
38838 PyThreadState* __tstate = wxPyBeginAllowThreads();
38839 (arg1)->Show(arg2);
38840
38841 wxPyEndAllowThreads(__tstate);
38842 if (PyErr_Occurred()) SWIG_fail;
38843 }
38844 Py_INCREF(Py_None); resultobj = Py_None;
38845 return resultobj;
38846 fail:
38847 return NULL;
38848 }
38849
38850
38851 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38852 PyObject *resultobj;
38853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38854 bool result;
38855 PyObject * obj0 = 0 ;
38856 char *kwnames[] = {
38857 (char *) "self", NULL
38858 };
38859
38860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38862 if (SWIG_arg_fail(1)) SWIG_fail;
38863 {
38864 PyThreadState* __tstate = wxPyBeginAllowThreads();
38865 result = (bool)(arg1)->IsShown();
38866
38867 wxPyEndAllowThreads(__tstate);
38868 if (PyErr_Occurred()) SWIG_fail;
38869 }
38870 {
38871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38872 }
38873 return resultobj;
38874 fail:
38875 return NULL;
38876 }
38877
38878
38879 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38880 PyObject *resultobj;
38881 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38882 wxPoint result;
38883 PyObject * obj0 = 0 ;
38884 char *kwnames[] = {
38885 (char *) "self", NULL
38886 };
38887
38888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38890 if (SWIG_arg_fail(1)) SWIG_fail;
38891 {
38892 PyThreadState* __tstate = wxPyBeginAllowThreads();
38893 result = (arg1)->GetPosition();
38894
38895 wxPyEndAllowThreads(__tstate);
38896 if (PyErr_Occurred()) SWIG_fail;
38897 }
38898 {
38899 wxPoint * resultptr;
38900 resultptr = new wxPoint((wxPoint &)(result));
38901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38902 }
38903 return resultobj;
38904 fail:
38905 return NULL;
38906 }
38907
38908
38909 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38910 PyObject *resultobj;
38911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38912 PyObject *result;
38913 PyObject * obj0 = 0 ;
38914 char *kwnames[] = {
38915 (char *) "self", NULL
38916 };
38917
38918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38920 if (SWIG_arg_fail(1)) SWIG_fail;
38921 {
38922 PyThreadState* __tstate = wxPyBeginAllowThreads();
38923 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38924
38925 wxPyEndAllowThreads(__tstate);
38926 if (PyErr_Occurred()) SWIG_fail;
38927 }
38928 resultobj = result;
38929 return resultobj;
38930 fail:
38931 return NULL;
38932 }
38933
38934
38935 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38936 PyObject *obj;
38937 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38938 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38939 Py_INCREF(obj);
38940 return Py_BuildValue((char *)"");
38941 }
38942 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38943 PyObject *resultobj;
38944 wxSizer *arg1 = (wxSizer *) 0 ;
38945 PyObject *arg2 = (PyObject *) 0 ;
38946 PyObject * obj0 = 0 ;
38947 PyObject * obj1 = 0 ;
38948 char *kwnames[] = {
38949 (char *) "self",(char *) "_self", NULL
38950 };
38951
38952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38954 if (SWIG_arg_fail(1)) SWIG_fail;
38955 arg2 = obj1;
38956 {
38957 PyThreadState* __tstate = wxPyBeginAllowThreads();
38958 wxSizer__setOORInfo(arg1,arg2);
38959
38960 wxPyEndAllowThreads(__tstate);
38961 if (PyErr_Occurred()) SWIG_fail;
38962 }
38963 Py_INCREF(Py_None); resultobj = Py_None;
38964 return resultobj;
38965 fail:
38966 return NULL;
38967 }
38968
38969
38970 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38971 PyObject *resultobj;
38972 wxSizer *arg1 = (wxSizer *) 0 ;
38973 PyObject *arg2 = (PyObject *) 0 ;
38974 int arg3 = (int) 0 ;
38975 int arg4 = (int) 0 ;
38976 int arg5 = (int) 0 ;
38977 PyObject *arg6 = (PyObject *) NULL ;
38978 wxSizerItem *result;
38979 PyObject * obj0 = 0 ;
38980 PyObject * obj1 = 0 ;
38981 PyObject * obj2 = 0 ;
38982 PyObject * obj3 = 0 ;
38983 PyObject * obj4 = 0 ;
38984 PyObject * obj5 = 0 ;
38985 char *kwnames[] = {
38986 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38987 };
38988
38989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38991 if (SWIG_arg_fail(1)) SWIG_fail;
38992 arg2 = obj1;
38993 if (obj2) {
38994 {
38995 arg3 = (int)(SWIG_As_int(obj2));
38996 if (SWIG_arg_fail(3)) SWIG_fail;
38997 }
38998 }
38999 if (obj3) {
39000 {
39001 arg4 = (int)(SWIG_As_int(obj3));
39002 if (SWIG_arg_fail(4)) SWIG_fail;
39003 }
39004 }
39005 if (obj4) {
39006 {
39007 arg5 = (int)(SWIG_As_int(obj4));
39008 if (SWIG_arg_fail(5)) SWIG_fail;
39009 }
39010 }
39011 if (obj5) {
39012 arg6 = obj5;
39013 }
39014 {
39015 PyThreadState* __tstate = wxPyBeginAllowThreads();
39016 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39017
39018 wxPyEndAllowThreads(__tstate);
39019 if (PyErr_Occurred()) SWIG_fail;
39020 }
39021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39029 PyObject *resultobj;
39030 wxSizer *arg1 = (wxSizer *) 0 ;
39031 int arg2 ;
39032 PyObject *arg3 = (PyObject *) 0 ;
39033 int arg4 = (int) 0 ;
39034 int arg5 = (int) 0 ;
39035 int arg6 = (int) 0 ;
39036 PyObject *arg7 = (PyObject *) NULL ;
39037 wxSizerItem *result;
39038 PyObject * obj0 = 0 ;
39039 PyObject * obj1 = 0 ;
39040 PyObject * obj2 = 0 ;
39041 PyObject * obj3 = 0 ;
39042 PyObject * obj4 = 0 ;
39043 PyObject * obj5 = 0 ;
39044 PyObject * obj6 = 0 ;
39045 char *kwnames[] = {
39046 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39047 };
39048
39049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39051 if (SWIG_arg_fail(1)) SWIG_fail;
39052 {
39053 arg2 = (int)(SWIG_As_int(obj1));
39054 if (SWIG_arg_fail(2)) SWIG_fail;
39055 }
39056 arg3 = obj2;
39057 if (obj3) {
39058 {
39059 arg4 = (int)(SWIG_As_int(obj3));
39060 if (SWIG_arg_fail(4)) SWIG_fail;
39061 }
39062 }
39063 if (obj4) {
39064 {
39065 arg5 = (int)(SWIG_As_int(obj4));
39066 if (SWIG_arg_fail(5)) SWIG_fail;
39067 }
39068 }
39069 if (obj5) {
39070 {
39071 arg6 = (int)(SWIG_As_int(obj5));
39072 if (SWIG_arg_fail(6)) SWIG_fail;
39073 }
39074 }
39075 if (obj6) {
39076 arg7 = obj6;
39077 }
39078 {
39079 PyThreadState* __tstate = wxPyBeginAllowThreads();
39080 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39081
39082 wxPyEndAllowThreads(__tstate);
39083 if (PyErr_Occurred()) SWIG_fail;
39084 }
39085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39086 return resultobj;
39087 fail:
39088 return NULL;
39089 }
39090
39091
39092 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39093 PyObject *resultobj;
39094 wxSizer *arg1 = (wxSizer *) 0 ;
39095 PyObject *arg2 = (PyObject *) 0 ;
39096 int arg3 = (int) 0 ;
39097 int arg4 = (int) 0 ;
39098 int arg5 = (int) 0 ;
39099 PyObject *arg6 = (PyObject *) NULL ;
39100 wxSizerItem *result;
39101 PyObject * obj0 = 0 ;
39102 PyObject * obj1 = 0 ;
39103 PyObject * obj2 = 0 ;
39104 PyObject * obj3 = 0 ;
39105 PyObject * obj4 = 0 ;
39106 PyObject * obj5 = 0 ;
39107 char *kwnames[] = {
39108 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39109 };
39110
39111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39113 if (SWIG_arg_fail(1)) SWIG_fail;
39114 arg2 = obj1;
39115 if (obj2) {
39116 {
39117 arg3 = (int)(SWIG_As_int(obj2));
39118 if (SWIG_arg_fail(3)) SWIG_fail;
39119 }
39120 }
39121 if (obj3) {
39122 {
39123 arg4 = (int)(SWIG_As_int(obj3));
39124 if (SWIG_arg_fail(4)) SWIG_fail;
39125 }
39126 }
39127 if (obj4) {
39128 {
39129 arg5 = (int)(SWIG_As_int(obj4));
39130 if (SWIG_arg_fail(5)) SWIG_fail;
39131 }
39132 }
39133 if (obj5) {
39134 arg6 = obj5;
39135 }
39136 {
39137 PyThreadState* __tstate = wxPyBeginAllowThreads();
39138 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39139
39140 wxPyEndAllowThreads(__tstate);
39141 if (PyErr_Occurred()) SWIG_fail;
39142 }
39143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39144 return resultobj;
39145 fail:
39146 return NULL;
39147 }
39148
39149
39150 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39151 PyObject *resultobj;
39152 wxSizer *arg1 = (wxSizer *) 0 ;
39153 PyObject *arg2 = (PyObject *) 0 ;
39154 bool result;
39155 PyObject * obj0 = 0 ;
39156 PyObject * obj1 = 0 ;
39157 char *kwnames[] = {
39158 (char *) "self",(char *) "item", NULL
39159 };
39160
39161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39163 if (SWIG_arg_fail(1)) SWIG_fail;
39164 arg2 = obj1;
39165 {
39166 PyThreadState* __tstate = wxPyBeginAllowThreads();
39167 result = (bool)wxSizer_Remove(arg1,arg2);
39168
39169 wxPyEndAllowThreads(__tstate);
39170 if (PyErr_Occurred()) SWIG_fail;
39171 }
39172 {
39173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39174 }
39175 return resultobj;
39176 fail:
39177 return NULL;
39178 }
39179
39180
39181 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39182 PyObject *resultobj;
39183 wxSizer *arg1 = (wxSizer *) 0 ;
39184 PyObject *arg2 = (PyObject *) 0 ;
39185 bool result;
39186 PyObject * obj0 = 0 ;
39187 PyObject * obj1 = 0 ;
39188 char *kwnames[] = {
39189 (char *) "self",(char *) "item", NULL
39190 };
39191
39192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39194 if (SWIG_arg_fail(1)) SWIG_fail;
39195 arg2 = obj1;
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 result = (bool)wxSizer_Detach(arg1,arg2);
39199
39200 wxPyEndAllowThreads(__tstate);
39201 if (PyErr_Occurred()) SWIG_fail;
39202 }
39203 {
39204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39205 }
39206 return resultobj;
39207 fail:
39208 return NULL;
39209 }
39210
39211
39212 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39213 PyObject *resultobj;
39214 wxSizer *arg1 = (wxSizer *) 0 ;
39215 PyObject *arg2 = (PyObject *) 0 ;
39216 wxSizerItem *result;
39217 PyObject * obj0 = 0 ;
39218 PyObject * obj1 = 0 ;
39219 char *kwnames[] = {
39220 (char *) "self",(char *) "item", NULL
39221 };
39222
39223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39225 if (SWIG_arg_fail(1)) SWIG_fail;
39226 arg2 = obj1;
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39230
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39235 return resultobj;
39236 fail:
39237 return NULL;
39238 }
39239
39240
39241 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39242 PyObject *resultobj;
39243 wxSizer *arg1 = (wxSizer *) 0 ;
39244 PyObject *arg2 = (PyObject *) 0 ;
39245 wxSize *arg3 = 0 ;
39246 wxSize temp3 ;
39247 PyObject * obj0 = 0 ;
39248 PyObject * obj1 = 0 ;
39249 PyObject * obj2 = 0 ;
39250 char *kwnames[] = {
39251 (char *) "self",(char *) "item",(char *) "size", NULL
39252 };
39253
39254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39256 if (SWIG_arg_fail(1)) SWIG_fail;
39257 arg2 = obj1;
39258 {
39259 arg3 = &temp3;
39260 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39261 }
39262 {
39263 PyThreadState* __tstate = wxPyBeginAllowThreads();
39264 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39265
39266 wxPyEndAllowThreads(__tstate);
39267 if (PyErr_Occurred()) SWIG_fail;
39268 }
39269 Py_INCREF(Py_None); resultobj = Py_None;
39270 return resultobj;
39271 fail:
39272 return NULL;
39273 }
39274
39275
39276 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39277 PyObject *resultobj;
39278 wxSizer *arg1 = (wxSizer *) 0 ;
39279 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39280 wxSizerItem *result;
39281 PyObject * obj0 = 0 ;
39282 PyObject * obj1 = 0 ;
39283 char *kwnames[] = {
39284 (char *) "self",(char *) "item", NULL
39285 };
39286
39287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39289 if (SWIG_arg_fail(1)) SWIG_fail;
39290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39291 if (SWIG_arg_fail(2)) SWIG_fail;
39292 {
39293 PyThreadState* __tstate = wxPyBeginAllowThreads();
39294 result = (wxSizerItem *)(arg1)->Add(arg2);
39295
39296 wxPyEndAllowThreads(__tstate);
39297 if (PyErr_Occurred()) SWIG_fail;
39298 }
39299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39300 return resultobj;
39301 fail:
39302 return NULL;
39303 }
39304
39305
39306 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39307 PyObject *resultobj;
39308 wxSizer *arg1 = (wxSizer *) 0 ;
39309 size_t arg2 ;
39310 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39311 wxSizerItem *result;
39312 PyObject * obj0 = 0 ;
39313 PyObject * obj1 = 0 ;
39314 PyObject * obj2 = 0 ;
39315 char *kwnames[] = {
39316 (char *) "self",(char *) "index",(char *) "item", NULL
39317 };
39318
39319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39321 if (SWIG_arg_fail(1)) SWIG_fail;
39322 {
39323 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39324 if (SWIG_arg_fail(2)) SWIG_fail;
39325 }
39326 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39327 if (SWIG_arg_fail(3)) SWIG_fail;
39328 {
39329 PyThreadState* __tstate = wxPyBeginAllowThreads();
39330 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39331
39332 wxPyEndAllowThreads(__tstate);
39333 if (PyErr_Occurred()) SWIG_fail;
39334 }
39335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39336 return resultobj;
39337 fail:
39338 return NULL;
39339 }
39340
39341
39342 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39343 PyObject *resultobj;
39344 wxSizer *arg1 = (wxSizer *) 0 ;
39345 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39346 wxSizerItem *result;
39347 PyObject * obj0 = 0 ;
39348 PyObject * obj1 = 0 ;
39349 char *kwnames[] = {
39350 (char *) "self",(char *) "item", NULL
39351 };
39352
39353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39355 if (SWIG_arg_fail(1)) SWIG_fail;
39356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39357 if (SWIG_arg_fail(2)) SWIG_fail;
39358 {
39359 PyThreadState* __tstate = wxPyBeginAllowThreads();
39360 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39361
39362 wxPyEndAllowThreads(__tstate);
39363 if (PyErr_Occurred()) SWIG_fail;
39364 }
39365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39366 return resultobj;
39367 fail:
39368 return NULL;
39369 }
39370
39371
39372 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39373 PyObject *resultobj;
39374 wxSizer *arg1 = (wxSizer *) 0 ;
39375 int arg2 ;
39376 int arg3 ;
39377 int arg4 ;
39378 int arg5 ;
39379 PyObject * obj0 = 0 ;
39380 PyObject * obj1 = 0 ;
39381 PyObject * obj2 = 0 ;
39382 PyObject * obj3 = 0 ;
39383 PyObject * obj4 = 0 ;
39384 char *kwnames[] = {
39385 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39386 };
39387
39388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(1)) SWIG_fail;
39391 {
39392 arg2 = (int)(SWIG_As_int(obj1));
39393 if (SWIG_arg_fail(2)) SWIG_fail;
39394 }
39395 {
39396 arg3 = (int)(SWIG_As_int(obj2));
39397 if (SWIG_arg_fail(3)) SWIG_fail;
39398 }
39399 {
39400 arg4 = (int)(SWIG_As_int(obj3));
39401 if (SWIG_arg_fail(4)) SWIG_fail;
39402 }
39403 {
39404 arg5 = (int)(SWIG_As_int(obj4));
39405 if (SWIG_arg_fail(5)) SWIG_fail;
39406 }
39407 {
39408 PyThreadState* __tstate = wxPyBeginAllowThreads();
39409 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39410
39411 wxPyEndAllowThreads(__tstate);
39412 if (PyErr_Occurred()) SWIG_fail;
39413 }
39414 Py_INCREF(Py_None); resultobj = Py_None;
39415 return resultobj;
39416 fail:
39417 return NULL;
39418 }
39419
39420
39421 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39422 PyObject *resultobj;
39423 wxSizer *arg1 = (wxSizer *) 0 ;
39424 wxSize *arg2 = 0 ;
39425 wxSize temp2 ;
39426 PyObject * obj0 = 0 ;
39427 PyObject * obj1 = 0 ;
39428 char *kwnames[] = {
39429 (char *) "self",(char *) "size", NULL
39430 };
39431
39432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39434 if (SWIG_arg_fail(1)) SWIG_fail;
39435 {
39436 arg2 = &temp2;
39437 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39438 }
39439 {
39440 PyThreadState* __tstate = wxPyBeginAllowThreads();
39441 (arg1)->SetMinSize((wxSize const &)*arg2);
39442
39443 wxPyEndAllowThreads(__tstate);
39444 if (PyErr_Occurred()) SWIG_fail;
39445 }
39446 Py_INCREF(Py_None); resultobj = Py_None;
39447 return resultobj;
39448 fail:
39449 return NULL;
39450 }
39451
39452
39453 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39454 PyObject *resultobj;
39455 wxSizer *arg1 = (wxSizer *) 0 ;
39456 wxSize result;
39457 PyObject * obj0 = 0 ;
39458 char *kwnames[] = {
39459 (char *) "self", NULL
39460 };
39461
39462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39464 if (SWIG_arg_fail(1)) SWIG_fail;
39465 {
39466 PyThreadState* __tstate = wxPyBeginAllowThreads();
39467 result = (arg1)->GetSize();
39468
39469 wxPyEndAllowThreads(__tstate);
39470 if (PyErr_Occurred()) SWIG_fail;
39471 }
39472 {
39473 wxSize * resultptr;
39474 resultptr = new wxSize((wxSize &)(result));
39475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39476 }
39477 return resultobj;
39478 fail:
39479 return NULL;
39480 }
39481
39482
39483 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39484 PyObject *resultobj;
39485 wxSizer *arg1 = (wxSizer *) 0 ;
39486 wxPoint result;
39487 PyObject * obj0 = 0 ;
39488 char *kwnames[] = {
39489 (char *) "self", NULL
39490 };
39491
39492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39494 if (SWIG_arg_fail(1)) SWIG_fail;
39495 {
39496 PyThreadState* __tstate = wxPyBeginAllowThreads();
39497 result = (arg1)->GetPosition();
39498
39499 wxPyEndAllowThreads(__tstate);
39500 if (PyErr_Occurred()) SWIG_fail;
39501 }
39502 {
39503 wxPoint * resultptr;
39504 resultptr = new wxPoint((wxPoint &)(result));
39505 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39506 }
39507 return resultobj;
39508 fail:
39509 return NULL;
39510 }
39511
39512
39513 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39514 PyObject *resultobj;
39515 wxSizer *arg1 = (wxSizer *) 0 ;
39516 wxSize result;
39517 PyObject * obj0 = 0 ;
39518 char *kwnames[] = {
39519 (char *) "self", NULL
39520 };
39521
39522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39524 if (SWIG_arg_fail(1)) SWIG_fail;
39525 {
39526 PyThreadState* __tstate = wxPyBeginAllowThreads();
39527 result = (arg1)->GetMinSize();
39528
39529 wxPyEndAllowThreads(__tstate);
39530 if (PyErr_Occurred()) SWIG_fail;
39531 }
39532 {
39533 wxSize * resultptr;
39534 resultptr = new wxSize((wxSize &)(result));
39535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39536 }
39537 return resultobj;
39538 fail:
39539 return NULL;
39540 }
39541
39542
39543 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39544 PyObject *resultobj;
39545 wxSizer *arg1 = (wxSizer *) 0 ;
39546 PyObject * obj0 = 0 ;
39547 char *kwnames[] = {
39548 (char *) "self", NULL
39549 };
39550
39551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39553 if (SWIG_arg_fail(1)) SWIG_fail;
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 (arg1)->RecalcSizes();
39557
39558 wxPyEndAllowThreads(__tstate);
39559 if (PyErr_Occurred()) SWIG_fail;
39560 }
39561 Py_INCREF(Py_None); resultobj = Py_None;
39562 return resultobj;
39563 fail:
39564 return NULL;
39565 }
39566
39567
39568 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39569 PyObject *resultobj;
39570 wxSizer *arg1 = (wxSizer *) 0 ;
39571 wxSize result;
39572 PyObject * obj0 = 0 ;
39573 char *kwnames[] = {
39574 (char *) "self", NULL
39575 };
39576
39577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39579 if (SWIG_arg_fail(1)) SWIG_fail;
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 result = (arg1)->CalcMin();
39583
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 {
39588 wxSize * resultptr;
39589 resultptr = new wxSize((wxSize &)(result));
39590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39591 }
39592 return resultobj;
39593 fail:
39594 return NULL;
39595 }
39596
39597
39598 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39599 PyObject *resultobj;
39600 wxSizer *arg1 = (wxSizer *) 0 ;
39601 PyObject * obj0 = 0 ;
39602 char *kwnames[] = {
39603 (char *) "self", NULL
39604 };
39605
39606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39608 if (SWIG_arg_fail(1)) SWIG_fail;
39609 {
39610 PyThreadState* __tstate = wxPyBeginAllowThreads();
39611 (arg1)->Layout();
39612
39613 wxPyEndAllowThreads(__tstate);
39614 if (PyErr_Occurred()) SWIG_fail;
39615 }
39616 Py_INCREF(Py_None); resultobj = Py_None;
39617 return resultobj;
39618 fail:
39619 return NULL;
39620 }
39621
39622
39623 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39624 PyObject *resultobj;
39625 wxSizer *arg1 = (wxSizer *) 0 ;
39626 wxWindow *arg2 = (wxWindow *) 0 ;
39627 wxSize result;
39628 PyObject * obj0 = 0 ;
39629 PyObject * obj1 = 0 ;
39630 char *kwnames[] = {
39631 (char *) "self",(char *) "window", NULL
39632 };
39633
39634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39636 if (SWIG_arg_fail(1)) SWIG_fail;
39637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39638 if (SWIG_arg_fail(2)) SWIG_fail;
39639 {
39640 PyThreadState* __tstate = wxPyBeginAllowThreads();
39641 result = (arg1)->Fit(arg2);
39642
39643 wxPyEndAllowThreads(__tstate);
39644 if (PyErr_Occurred()) SWIG_fail;
39645 }
39646 {
39647 wxSize * resultptr;
39648 resultptr = new wxSize((wxSize &)(result));
39649 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39650 }
39651 return resultobj;
39652 fail:
39653 return NULL;
39654 }
39655
39656
39657 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39658 PyObject *resultobj;
39659 wxSizer *arg1 = (wxSizer *) 0 ;
39660 wxWindow *arg2 = (wxWindow *) 0 ;
39661 PyObject * obj0 = 0 ;
39662 PyObject * obj1 = 0 ;
39663 char *kwnames[] = {
39664 (char *) "self",(char *) "window", NULL
39665 };
39666
39667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39669 if (SWIG_arg_fail(1)) SWIG_fail;
39670 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39671 if (SWIG_arg_fail(2)) SWIG_fail;
39672 {
39673 PyThreadState* __tstate = wxPyBeginAllowThreads();
39674 (arg1)->FitInside(arg2);
39675
39676 wxPyEndAllowThreads(__tstate);
39677 if (PyErr_Occurred()) SWIG_fail;
39678 }
39679 Py_INCREF(Py_None); resultobj = Py_None;
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39687 PyObject *resultobj;
39688 wxSizer *arg1 = (wxSizer *) 0 ;
39689 wxWindow *arg2 = (wxWindow *) 0 ;
39690 PyObject * obj0 = 0 ;
39691 PyObject * obj1 = 0 ;
39692 char *kwnames[] = {
39693 (char *) "self",(char *) "window", NULL
39694 };
39695
39696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39698 if (SWIG_arg_fail(1)) SWIG_fail;
39699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39700 if (SWIG_arg_fail(2)) SWIG_fail;
39701 {
39702 PyThreadState* __tstate = wxPyBeginAllowThreads();
39703 (arg1)->SetSizeHints(arg2);
39704
39705 wxPyEndAllowThreads(__tstate);
39706 if (PyErr_Occurred()) SWIG_fail;
39707 }
39708 Py_INCREF(Py_None); resultobj = Py_None;
39709 return resultobj;
39710 fail:
39711 return NULL;
39712 }
39713
39714
39715 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39716 PyObject *resultobj;
39717 wxSizer *arg1 = (wxSizer *) 0 ;
39718 wxWindow *arg2 = (wxWindow *) 0 ;
39719 PyObject * obj0 = 0 ;
39720 PyObject * obj1 = 0 ;
39721 char *kwnames[] = {
39722 (char *) "self",(char *) "window", NULL
39723 };
39724
39725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39727 if (SWIG_arg_fail(1)) SWIG_fail;
39728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39729 if (SWIG_arg_fail(2)) SWIG_fail;
39730 {
39731 PyThreadState* __tstate = wxPyBeginAllowThreads();
39732 (arg1)->SetVirtualSizeHints(arg2);
39733
39734 wxPyEndAllowThreads(__tstate);
39735 if (PyErr_Occurred()) SWIG_fail;
39736 }
39737 Py_INCREF(Py_None); resultobj = Py_None;
39738 return resultobj;
39739 fail:
39740 return NULL;
39741 }
39742
39743
39744 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39745 PyObject *resultobj;
39746 wxSizer *arg1 = (wxSizer *) 0 ;
39747 bool arg2 = (bool) false ;
39748 PyObject * obj0 = 0 ;
39749 PyObject * obj1 = 0 ;
39750 char *kwnames[] = {
39751 (char *) "self",(char *) "deleteWindows", NULL
39752 };
39753
39754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39756 if (SWIG_arg_fail(1)) SWIG_fail;
39757 if (obj1) {
39758 {
39759 arg2 = (bool)(SWIG_As_bool(obj1));
39760 if (SWIG_arg_fail(2)) SWIG_fail;
39761 }
39762 }
39763 {
39764 PyThreadState* __tstate = wxPyBeginAllowThreads();
39765 (arg1)->Clear(arg2);
39766
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 Py_INCREF(Py_None); resultobj = Py_None;
39771 return resultobj;
39772 fail:
39773 return NULL;
39774 }
39775
39776
39777 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39778 PyObject *resultobj;
39779 wxSizer *arg1 = (wxSizer *) 0 ;
39780 PyObject * obj0 = 0 ;
39781 char *kwnames[] = {
39782 (char *) "self", NULL
39783 };
39784
39785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39787 if (SWIG_arg_fail(1)) SWIG_fail;
39788 {
39789 PyThreadState* __tstate = wxPyBeginAllowThreads();
39790 (arg1)->DeleteWindows();
39791
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 Py_INCREF(Py_None); resultobj = Py_None;
39796 return resultobj;
39797 fail:
39798 return NULL;
39799 }
39800
39801
39802 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39803 PyObject *resultobj;
39804 wxSizer *arg1 = (wxSizer *) 0 ;
39805 PyObject *result;
39806 PyObject * obj0 = 0 ;
39807 char *kwnames[] = {
39808 (char *) "self", NULL
39809 };
39810
39811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39813 if (SWIG_arg_fail(1)) SWIG_fail;
39814 {
39815 PyThreadState* __tstate = wxPyBeginAllowThreads();
39816 result = (PyObject *)wxSizer_GetChildren(arg1);
39817
39818 wxPyEndAllowThreads(__tstate);
39819 if (PyErr_Occurred()) SWIG_fail;
39820 }
39821 resultobj = result;
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj;
39830 wxSizer *arg1 = (wxSizer *) 0 ;
39831 PyObject *arg2 = (PyObject *) 0 ;
39832 bool arg3 = (bool) true ;
39833 bool arg4 = (bool) false ;
39834 bool result;
39835 PyObject * obj0 = 0 ;
39836 PyObject * obj1 = 0 ;
39837 PyObject * obj2 = 0 ;
39838 PyObject * obj3 = 0 ;
39839 char *kwnames[] = {
39840 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39841 };
39842
39843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39845 if (SWIG_arg_fail(1)) SWIG_fail;
39846 arg2 = obj1;
39847 if (obj2) {
39848 {
39849 arg3 = (bool)(SWIG_As_bool(obj2));
39850 if (SWIG_arg_fail(3)) SWIG_fail;
39851 }
39852 }
39853 if (obj3) {
39854 {
39855 arg4 = (bool)(SWIG_As_bool(obj3));
39856 if (SWIG_arg_fail(4)) SWIG_fail;
39857 }
39858 }
39859 {
39860 PyThreadState* __tstate = wxPyBeginAllowThreads();
39861 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39862
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 {
39867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39868 }
39869 return resultobj;
39870 fail:
39871 return NULL;
39872 }
39873
39874
39875 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39876 PyObject *resultobj;
39877 wxSizer *arg1 = (wxSizer *) 0 ;
39878 PyObject *arg2 = (PyObject *) 0 ;
39879 bool result;
39880 PyObject * obj0 = 0 ;
39881 PyObject * obj1 = 0 ;
39882 char *kwnames[] = {
39883 (char *) "self",(char *) "item", NULL
39884 };
39885
39886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39888 if (SWIG_arg_fail(1)) SWIG_fail;
39889 arg2 = obj1;
39890 {
39891 PyThreadState* __tstate = wxPyBeginAllowThreads();
39892 result = (bool)wxSizer_IsShown(arg1,arg2);
39893
39894 wxPyEndAllowThreads(__tstate);
39895 if (PyErr_Occurred()) SWIG_fail;
39896 }
39897 {
39898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39899 }
39900 return resultobj;
39901 fail:
39902 return NULL;
39903 }
39904
39905
39906 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39907 PyObject *resultobj;
39908 wxSizer *arg1 = (wxSizer *) 0 ;
39909 bool arg2 ;
39910 PyObject * obj0 = 0 ;
39911 PyObject * obj1 = 0 ;
39912 char *kwnames[] = {
39913 (char *) "self",(char *) "show", NULL
39914 };
39915
39916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39918 if (SWIG_arg_fail(1)) SWIG_fail;
39919 {
39920 arg2 = (bool)(SWIG_As_bool(obj1));
39921 if (SWIG_arg_fail(2)) SWIG_fail;
39922 }
39923 {
39924 PyThreadState* __tstate = wxPyBeginAllowThreads();
39925 (arg1)->ShowItems(arg2);
39926
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 Py_INCREF(Py_None); resultobj = Py_None;
39931 return resultobj;
39932 fail:
39933 return NULL;
39934 }
39935
39936
39937 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39938 PyObject *obj;
39939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39940 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39941 Py_INCREF(obj);
39942 return Py_BuildValue((char *)"");
39943 }
39944 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39945 PyObject *resultobj;
39946 wxPySizer *result;
39947 char *kwnames[] = {
39948 NULL
39949 };
39950
39951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39952 {
39953 PyThreadState* __tstate = wxPyBeginAllowThreads();
39954 result = (wxPySizer *)new wxPySizer();
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj;
39968 wxPySizer *arg1 = (wxPySizer *) 0 ;
39969 PyObject *arg2 = (PyObject *) 0 ;
39970 PyObject *arg3 = (PyObject *) 0 ;
39971 PyObject * obj0 = 0 ;
39972 PyObject * obj1 = 0 ;
39973 PyObject * obj2 = 0 ;
39974 char *kwnames[] = {
39975 (char *) "self",(char *) "self",(char *) "_class", NULL
39976 };
39977
39978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39980 if (SWIG_arg_fail(1)) SWIG_fail;
39981 arg2 = obj1;
39982 arg3 = obj2;
39983 {
39984 PyThreadState* __tstate = wxPyBeginAllowThreads();
39985 (arg1)->_setCallbackInfo(arg2,arg3);
39986
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 Py_INCREF(Py_None); resultobj = Py_None;
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39998 PyObject *obj;
39999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40000 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40001 Py_INCREF(obj);
40002 return Py_BuildValue((char *)"");
40003 }
40004 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40005 PyObject *resultobj;
40006 int arg1 = (int) wxHORIZONTAL ;
40007 wxBoxSizer *result;
40008 PyObject * obj0 = 0 ;
40009 char *kwnames[] = {
40010 (char *) "orient", NULL
40011 };
40012
40013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40014 if (obj0) {
40015 {
40016 arg1 = (int)(SWIG_As_int(obj0));
40017 if (SWIG_arg_fail(1)) SWIG_fail;
40018 }
40019 }
40020 {
40021 PyThreadState* __tstate = wxPyBeginAllowThreads();
40022 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40023
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40028 return resultobj;
40029 fail:
40030 return NULL;
40031 }
40032
40033
40034 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40035 PyObject *resultobj;
40036 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40037 int result;
40038 PyObject * obj0 = 0 ;
40039 char *kwnames[] = {
40040 (char *) "self", NULL
40041 };
40042
40043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40045 if (SWIG_arg_fail(1)) SWIG_fail;
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 result = (int)(arg1)->GetOrientation();
40049
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 {
40054 resultobj = SWIG_From_int((int)(result));
40055 }
40056 return resultobj;
40057 fail:
40058 return NULL;
40059 }
40060
40061
40062 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40063 PyObject *resultobj;
40064 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40065 int arg2 ;
40066 PyObject * obj0 = 0 ;
40067 PyObject * obj1 = 0 ;
40068 char *kwnames[] = {
40069 (char *) "self",(char *) "orient", NULL
40070 };
40071
40072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40074 if (SWIG_arg_fail(1)) SWIG_fail;
40075 {
40076 arg2 = (int)(SWIG_As_int(obj1));
40077 if (SWIG_arg_fail(2)) SWIG_fail;
40078 }
40079 {
40080 PyThreadState* __tstate = wxPyBeginAllowThreads();
40081 (arg1)->SetOrientation(arg2);
40082
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 Py_INCREF(Py_None); resultobj = Py_None;
40087 return resultobj;
40088 fail:
40089 return NULL;
40090 }
40091
40092
40093 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40094 PyObject *obj;
40095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40096 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40097 Py_INCREF(obj);
40098 return Py_BuildValue((char *)"");
40099 }
40100 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40101 PyObject *resultobj;
40102 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40103 int arg2 = (int) wxHORIZONTAL ;
40104 wxStaticBoxSizer *result;
40105 PyObject * obj0 = 0 ;
40106 PyObject * obj1 = 0 ;
40107 char *kwnames[] = {
40108 (char *) "box",(char *) "orient", NULL
40109 };
40110
40111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40113 if (SWIG_arg_fail(1)) SWIG_fail;
40114 if (obj1) {
40115 {
40116 arg2 = (int)(SWIG_As_int(obj1));
40117 if (SWIG_arg_fail(2)) SWIG_fail;
40118 }
40119 }
40120 {
40121 PyThreadState* __tstate = wxPyBeginAllowThreads();
40122 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40123
40124 wxPyEndAllowThreads(__tstate);
40125 if (PyErr_Occurred()) SWIG_fail;
40126 }
40127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40128 return resultobj;
40129 fail:
40130 return NULL;
40131 }
40132
40133
40134 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40135 PyObject *resultobj;
40136 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40137 wxStaticBox *result;
40138 PyObject * obj0 = 0 ;
40139 char *kwnames[] = {
40140 (char *) "self", NULL
40141 };
40142
40143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40145 if (SWIG_arg_fail(1)) SWIG_fail;
40146 {
40147 PyThreadState* __tstate = wxPyBeginAllowThreads();
40148 result = (wxStaticBox *)(arg1)->GetStaticBox();
40149
40150 wxPyEndAllowThreads(__tstate);
40151 if (PyErr_Occurred()) SWIG_fail;
40152 }
40153 {
40154 resultobj = wxPyMake_wxObject(result, 0);
40155 }
40156 return resultobj;
40157 fail:
40158 return NULL;
40159 }
40160
40161
40162 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40163 PyObject *obj;
40164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40165 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40166 Py_INCREF(obj);
40167 return Py_BuildValue((char *)"");
40168 }
40169 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40170 PyObject *resultobj;
40171 int arg1 = (int) 1 ;
40172 int arg2 = (int) 0 ;
40173 int arg3 = (int) 0 ;
40174 int arg4 = (int) 0 ;
40175 wxGridSizer *result;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 PyObject * obj2 = 0 ;
40179 PyObject * obj3 = 0 ;
40180 char *kwnames[] = {
40181 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40182 };
40183
40184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40185 if (obj0) {
40186 {
40187 arg1 = (int)(SWIG_As_int(obj0));
40188 if (SWIG_arg_fail(1)) SWIG_fail;
40189 }
40190 }
40191 if (obj1) {
40192 {
40193 arg2 = (int)(SWIG_As_int(obj1));
40194 if (SWIG_arg_fail(2)) SWIG_fail;
40195 }
40196 }
40197 if (obj2) {
40198 {
40199 arg3 = (int)(SWIG_As_int(obj2));
40200 if (SWIG_arg_fail(3)) SWIG_fail;
40201 }
40202 }
40203 if (obj3) {
40204 {
40205 arg4 = (int)(SWIG_As_int(obj3));
40206 if (SWIG_arg_fail(4)) SWIG_fail;
40207 }
40208 }
40209 {
40210 PyThreadState* __tstate = wxPyBeginAllowThreads();
40211 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40212
40213 wxPyEndAllowThreads(__tstate);
40214 if (PyErr_Occurred()) SWIG_fail;
40215 }
40216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40217 return resultobj;
40218 fail:
40219 return NULL;
40220 }
40221
40222
40223 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40224 PyObject *resultobj;
40225 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40226 int arg2 ;
40227 PyObject * obj0 = 0 ;
40228 PyObject * obj1 = 0 ;
40229 char *kwnames[] = {
40230 (char *) "self",(char *) "cols", NULL
40231 };
40232
40233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40235 if (SWIG_arg_fail(1)) SWIG_fail;
40236 {
40237 arg2 = (int)(SWIG_As_int(obj1));
40238 if (SWIG_arg_fail(2)) SWIG_fail;
40239 }
40240 {
40241 PyThreadState* __tstate = wxPyBeginAllowThreads();
40242 (arg1)->SetCols(arg2);
40243
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 Py_INCREF(Py_None); resultobj = Py_None;
40248 return resultobj;
40249 fail:
40250 return NULL;
40251 }
40252
40253
40254 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40255 PyObject *resultobj;
40256 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40257 int arg2 ;
40258 PyObject * obj0 = 0 ;
40259 PyObject * obj1 = 0 ;
40260 char *kwnames[] = {
40261 (char *) "self",(char *) "rows", NULL
40262 };
40263
40264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40266 if (SWIG_arg_fail(1)) SWIG_fail;
40267 {
40268 arg2 = (int)(SWIG_As_int(obj1));
40269 if (SWIG_arg_fail(2)) SWIG_fail;
40270 }
40271 {
40272 PyThreadState* __tstate = wxPyBeginAllowThreads();
40273 (arg1)->SetRows(arg2);
40274
40275 wxPyEndAllowThreads(__tstate);
40276 if (PyErr_Occurred()) SWIG_fail;
40277 }
40278 Py_INCREF(Py_None); resultobj = Py_None;
40279 return resultobj;
40280 fail:
40281 return NULL;
40282 }
40283
40284
40285 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40286 PyObject *resultobj;
40287 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40288 int arg2 ;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 char *kwnames[] = {
40292 (char *) "self",(char *) "gap", NULL
40293 };
40294
40295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40297 if (SWIG_arg_fail(1)) SWIG_fail;
40298 {
40299 arg2 = (int)(SWIG_As_int(obj1));
40300 if (SWIG_arg_fail(2)) SWIG_fail;
40301 }
40302 {
40303 PyThreadState* __tstate = wxPyBeginAllowThreads();
40304 (arg1)->SetVGap(arg2);
40305
40306 wxPyEndAllowThreads(__tstate);
40307 if (PyErr_Occurred()) SWIG_fail;
40308 }
40309 Py_INCREF(Py_None); resultobj = Py_None;
40310 return resultobj;
40311 fail:
40312 return NULL;
40313 }
40314
40315
40316 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj;
40318 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40319 int arg2 ;
40320 PyObject * obj0 = 0 ;
40321 PyObject * obj1 = 0 ;
40322 char *kwnames[] = {
40323 (char *) "self",(char *) "gap", NULL
40324 };
40325
40326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40328 if (SWIG_arg_fail(1)) SWIG_fail;
40329 {
40330 arg2 = (int)(SWIG_As_int(obj1));
40331 if (SWIG_arg_fail(2)) SWIG_fail;
40332 }
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->SetHGap(arg2);
40336
40337 wxPyEndAllowThreads(__tstate);
40338 if (PyErr_Occurred()) SWIG_fail;
40339 }
40340 Py_INCREF(Py_None); resultobj = Py_None;
40341 return resultobj;
40342 fail:
40343 return NULL;
40344 }
40345
40346
40347 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40348 PyObject *resultobj;
40349 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40350 int result;
40351 PyObject * obj0 = 0 ;
40352 char *kwnames[] = {
40353 (char *) "self", NULL
40354 };
40355
40356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40358 if (SWIG_arg_fail(1)) SWIG_fail;
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 result = (int)(arg1)->GetCols();
40362
40363 wxPyEndAllowThreads(__tstate);
40364 if (PyErr_Occurred()) SWIG_fail;
40365 }
40366 {
40367 resultobj = SWIG_From_int((int)(result));
40368 }
40369 return resultobj;
40370 fail:
40371 return NULL;
40372 }
40373
40374
40375 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40376 PyObject *resultobj;
40377 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40378 int result;
40379 PyObject * obj0 = 0 ;
40380 char *kwnames[] = {
40381 (char *) "self", NULL
40382 };
40383
40384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40386 if (SWIG_arg_fail(1)) SWIG_fail;
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 result = (int)(arg1)->GetRows();
40390
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 {
40395 resultobj = SWIG_From_int((int)(result));
40396 }
40397 return resultobj;
40398 fail:
40399 return NULL;
40400 }
40401
40402
40403 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40404 PyObject *resultobj;
40405 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40406 int result;
40407 PyObject * obj0 = 0 ;
40408 char *kwnames[] = {
40409 (char *) "self", NULL
40410 };
40411
40412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40414 if (SWIG_arg_fail(1)) SWIG_fail;
40415 {
40416 PyThreadState* __tstate = wxPyBeginAllowThreads();
40417 result = (int)(arg1)->GetVGap();
40418
40419 wxPyEndAllowThreads(__tstate);
40420 if (PyErr_Occurred()) SWIG_fail;
40421 }
40422 {
40423 resultobj = SWIG_From_int((int)(result));
40424 }
40425 return resultobj;
40426 fail:
40427 return NULL;
40428 }
40429
40430
40431 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40432 PyObject *resultobj;
40433 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40434 int result;
40435 PyObject * obj0 = 0 ;
40436 char *kwnames[] = {
40437 (char *) "self", NULL
40438 };
40439
40440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40442 if (SWIG_arg_fail(1)) SWIG_fail;
40443 {
40444 PyThreadState* __tstate = wxPyBeginAllowThreads();
40445 result = (int)(arg1)->GetHGap();
40446
40447 wxPyEndAllowThreads(__tstate);
40448 if (PyErr_Occurred()) SWIG_fail;
40449 }
40450 {
40451 resultobj = SWIG_From_int((int)(result));
40452 }
40453 return resultobj;
40454 fail:
40455 return NULL;
40456 }
40457
40458
40459 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40460 PyObject *obj;
40461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40462 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40463 Py_INCREF(obj);
40464 return Py_BuildValue((char *)"");
40465 }
40466 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj;
40468 int arg1 = (int) 1 ;
40469 int arg2 = (int) 0 ;
40470 int arg3 = (int) 0 ;
40471 int arg4 = (int) 0 ;
40472 wxFlexGridSizer *result;
40473 PyObject * obj0 = 0 ;
40474 PyObject * obj1 = 0 ;
40475 PyObject * obj2 = 0 ;
40476 PyObject * obj3 = 0 ;
40477 char *kwnames[] = {
40478 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40479 };
40480
40481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40482 if (obj0) {
40483 {
40484 arg1 = (int)(SWIG_As_int(obj0));
40485 if (SWIG_arg_fail(1)) SWIG_fail;
40486 }
40487 }
40488 if (obj1) {
40489 {
40490 arg2 = (int)(SWIG_As_int(obj1));
40491 if (SWIG_arg_fail(2)) SWIG_fail;
40492 }
40493 }
40494 if (obj2) {
40495 {
40496 arg3 = (int)(SWIG_As_int(obj2));
40497 if (SWIG_arg_fail(3)) SWIG_fail;
40498 }
40499 }
40500 if (obj3) {
40501 {
40502 arg4 = (int)(SWIG_As_int(obj3));
40503 if (SWIG_arg_fail(4)) SWIG_fail;
40504 }
40505 }
40506 {
40507 PyThreadState* __tstate = wxPyBeginAllowThreads();
40508 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40509
40510 wxPyEndAllowThreads(__tstate);
40511 if (PyErr_Occurred()) SWIG_fail;
40512 }
40513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40514 return resultobj;
40515 fail:
40516 return NULL;
40517 }
40518
40519
40520 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40521 PyObject *resultobj;
40522 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40523 size_t arg2 ;
40524 int arg3 = (int) 0 ;
40525 PyObject * obj0 = 0 ;
40526 PyObject * obj1 = 0 ;
40527 PyObject * obj2 = 0 ;
40528 char *kwnames[] = {
40529 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40530 };
40531
40532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40534 if (SWIG_arg_fail(1)) SWIG_fail;
40535 {
40536 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40537 if (SWIG_arg_fail(2)) SWIG_fail;
40538 }
40539 if (obj2) {
40540 {
40541 arg3 = (int)(SWIG_As_int(obj2));
40542 if (SWIG_arg_fail(3)) SWIG_fail;
40543 }
40544 }
40545 {
40546 PyThreadState* __tstate = wxPyBeginAllowThreads();
40547 (arg1)->AddGrowableRow(arg2,arg3);
40548
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 Py_INCREF(Py_None); resultobj = Py_None;
40553 return resultobj;
40554 fail:
40555 return NULL;
40556 }
40557
40558
40559 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40560 PyObject *resultobj;
40561 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40562 size_t arg2 ;
40563 PyObject * obj0 = 0 ;
40564 PyObject * obj1 = 0 ;
40565 char *kwnames[] = {
40566 (char *) "self",(char *) "idx", NULL
40567 };
40568
40569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40571 if (SWIG_arg_fail(1)) SWIG_fail;
40572 {
40573 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40574 if (SWIG_arg_fail(2)) SWIG_fail;
40575 }
40576 {
40577 PyThreadState* __tstate = wxPyBeginAllowThreads();
40578 (arg1)->RemoveGrowableRow(arg2);
40579
40580 wxPyEndAllowThreads(__tstate);
40581 if (PyErr_Occurred()) SWIG_fail;
40582 }
40583 Py_INCREF(Py_None); resultobj = Py_None;
40584 return resultobj;
40585 fail:
40586 return NULL;
40587 }
40588
40589
40590 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40591 PyObject *resultobj;
40592 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40593 size_t arg2 ;
40594 int arg3 = (int) 0 ;
40595 PyObject * obj0 = 0 ;
40596 PyObject * obj1 = 0 ;
40597 PyObject * obj2 = 0 ;
40598 char *kwnames[] = {
40599 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40600 };
40601
40602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40604 if (SWIG_arg_fail(1)) SWIG_fail;
40605 {
40606 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40607 if (SWIG_arg_fail(2)) SWIG_fail;
40608 }
40609 if (obj2) {
40610 {
40611 arg3 = (int)(SWIG_As_int(obj2));
40612 if (SWIG_arg_fail(3)) SWIG_fail;
40613 }
40614 }
40615 {
40616 PyThreadState* __tstate = wxPyBeginAllowThreads();
40617 (arg1)->AddGrowableCol(arg2,arg3);
40618
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 Py_INCREF(Py_None); resultobj = Py_None;
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40630 PyObject *resultobj;
40631 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40632 size_t arg2 ;
40633 PyObject * obj0 = 0 ;
40634 PyObject * obj1 = 0 ;
40635 char *kwnames[] = {
40636 (char *) "self",(char *) "idx", NULL
40637 };
40638
40639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40641 if (SWIG_arg_fail(1)) SWIG_fail;
40642 {
40643 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40644 if (SWIG_arg_fail(2)) SWIG_fail;
40645 }
40646 {
40647 PyThreadState* __tstate = wxPyBeginAllowThreads();
40648 (arg1)->RemoveGrowableCol(arg2);
40649
40650 wxPyEndAllowThreads(__tstate);
40651 if (PyErr_Occurred()) SWIG_fail;
40652 }
40653 Py_INCREF(Py_None); resultobj = Py_None;
40654 return resultobj;
40655 fail:
40656 return NULL;
40657 }
40658
40659
40660 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40661 PyObject *resultobj;
40662 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40663 int arg2 ;
40664 PyObject * obj0 = 0 ;
40665 PyObject * obj1 = 0 ;
40666 char *kwnames[] = {
40667 (char *) "self",(char *) "direction", NULL
40668 };
40669
40670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40672 if (SWIG_arg_fail(1)) SWIG_fail;
40673 {
40674 arg2 = (int)(SWIG_As_int(obj1));
40675 if (SWIG_arg_fail(2)) SWIG_fail;
40676 }
40677 {
40678 PyThreadState* __tstate = wxPyBeginAllowThreads();
40679 (arg1)->SetFlexibleDirection(arg2);
40680
40681 wxPyEndAllowThreads(__tstate);
40682 if (PyErr_Occurred()) SWIG_fail;
40683 }
40684 Py_INCREF(Py_None); resultobj = Py_None;
40685 return resultobj;
40686 fail:
40687 return NULL;
40688 }
40689
40690
40691 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40692 PyObject *resultobj;
40693 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40694 int result;
40695 PyObject * obj0 = 0 ;
40696 char *kwnames[] = {
40697 (char *) "self", NULL
40698 };
40699
40700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40702 if (SWIG_arg_fail(1)) SWIG_fail;
40703 {
40704 PyThreadState* __tstate = wxPyBeginAllowThreads();
40705 result = (int)(arg1)->GetFlexibleDirection();
40706
40707 wxPyEndAllowThreads(__tstate);
40708 if (PyErr_Occurred()) SWIG_fail;
40709 }
40710 {
40711 resultobj = SWIG_From_int((int)(result));
40712 }
40713 return resultobj;
40714 fail:
40715 return NULL;
40716 }
40717
40718
40719 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40720 PyObject *resultobj;
40721 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40722 wxFlexSizerGrowMode arg2 ;
40723 PyObject * obj0 = 0 ;
40724 PyObject * obj1 = 0 ;
40725 char *kwnames[] = {
40726 (char *) "self",(char *) "mode", NULL
40727 };
40728
40729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40731 if (SWIG_arg_fail(1)) SWIG_fail;
40732 {
40733 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40734 if (SWIG_arg_fail(2)) SWIG_fail;
40735 }
40736 {
40737 PyThreadState* __tstate = wxPyBeginAllowThreads();
40738 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40739
40740 wxPyEndAllowThreads(__tstate);
40741 if (PyErr_Occurred()) SWIG_fail;
40742 }
40743 Py_INCREF(Py_None); resultobj = Py_None;
40744 return resultobj;
40745 fail:
40746 return NULL;
40747 }
40748
40749
40750 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40751 PyObject *resultobj;
40752 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40753 wxFlexSizerGrowMode result;
40754 PyObject * obj0 = 0 ;
40755 char *kwnames[] = {
40756 (char *) "self", NULL
40757 };
40758
40759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40761 if (SWIG_arg_fail(1)) SWIG_fail;
40762 {
40763 PyThreadState* __tstate = wxPyBeginAllowThreads();
40764 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40765
40766 wxPyEndAllowThreads(__tstate);
40767 if (PyErr_Occurred()) SWIG_fail;
40768 }
40769 resultobj = SWIG_From_int((result));
40770 return resultobj;
40771 fail:
40772 return NULL;
40773 }
40774
40775
40776 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40777 PyObject *resultobj;
40778 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40779 wxArrayInt *result;
40780 PyObject * obj0 = 0 ;
40781 char *kwnames[] = {
40782 (char *) "self", NULL
40783 };
40784
40785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40787 if (SWIG_arg_fail(1)) SWIG_fail;
40788 {
40789 PyThreadState* __tstate = wxPyBeginAllowThreads();
40790 {
40791 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40792 result = (wxArrayInt *) &_result_ref;
40793 }
40794
40795 wxPyEndAllowThreads(__tstate);
40796 if (PyErr_Occurred()) SWIG_fail;
40797 }
40798 {
40799 resultobj = PyList_New(0);
40800 size_t idx;
40801 for (idx = 0; idx < result->GetCount(); idx += 1) {
40802 PyObject* val = PyInt_FromLong( result->Item(idx) );
40803 PyList_Append(resultobj, val);
40804 Py_DECREF(val);
40805 }
40806 }
40807 return resultobj;
40808 fail:
40809 return NULL;
40810 }
40811
40812
40813 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40814 PyObject *resultobj;
40815 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40816 wxArrayInt *result;
40817 PyObject * obj0 = 0 ;
40818 char *kwnames[] = {
40819 (char *) "self", NULL
40820 };
40821
40822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40824 if (SWIG_arg_fail(1)) SWIG_fail;
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 {
40828 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40829 result = (wxArrayInt *) &_result_ref;
40830 }
40831
40832 wxPyEndAllowThreads(__tstate);
40833 if (PyErr_Occurred()) SWIG_fail;
40834 }
40835 {
40836 resultobj = PyList_New(0);
40837 size_t idx;
40838 for (idx = 0; idx < result->GetCount(); idx += 1) {
40839 PyObject* val = PyInt_FromLong( result->Item(idx) );
40840 PyList_Append(resultobj, val);
40841 Py_DECREF(val);
40842 }
40843 }
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40851 PyObject *obj;
40852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40853 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40854 Py_INCREF(obj);
40855 return Py_BuildValue((char *)"");
40856 }
40857 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40858 PyObject *resultobj;
40859 wxStdDialogButtonSizer *result;
40860 char *kwnames[] = {
40861 NULL
40862 };
40863
40864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40868
40869 wxPyEndAllowThreads(__tstate);
40870 if (PyErr_Occurred()) SWIG_fail;
40871 }
40872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40873 return resultobj;
40874 fail:
40875 return NULL;
40876 }
40877
40878
40879 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40880 PyObject *resultobj;
40881 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40882 wxButton *arg2 = (wxButton *) 0 ;
40883 PyObject * obj0 = 0 ;
40884 PyObject * obj1 = 0 ;
40885 char *kwnames[] = {
40886 (char *) "self",(char *) "button", NULL
40887 };
40888
40889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40891 if (SWIG_arg_fail(1)) SWIG_fail;
40892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40893 if (SWIG_arg_fail(2)) SWIG_fail;
40894 {
40895 PyThreadState* __tstate = wxPyBeginAllowThreads();
40896 (arg1)->AddButton(arg2);
40897
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 Py_INCREF(Py_None); resultobj = Py_None;
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40909 PyObject *resultobj;
40910 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40911 PyObject * obj0 = 0 ;
40912 char *kwnames[] = {
40913 (char *) "self", NULL
40914 };
40915
40916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40918 if (SWIG_arg_fail(1)) SWIG_fail;
40919 {
40920 PyThreadState* __tstate = wxPyBeginAllowThreads();
40921 (arg1)->Realize();
40922
40923 wxPyEndAllowThreads(__tstate);
40924 if (PyErr_Occurred()) SWIG_fail;
40925 }
40926 Py_INCREF(Py_None); resultobj = Py_None;
40927 return resultobj;
40928 fail:
40929 return NULL;
40930 }
40931
40932
40933 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40934 PyObject *resultobj;
40935 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40936 wxButton *arg2 = (wxButton *) 0 ;
40937 PyObject * obj0 = 0 ;
40938 PyObject * obj1 = 0 ;
40939 char *kwnames[] = {
40940 (char *) "self",(char *) "button", NULL
40941 };
40942
40943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40945 if (SWIG_arg_fail(1)) SWIG_fail;
40946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40947 if (SWIG_arg_fail(2)) SWIG_fail;
40948 {
40949 PyThreadState* __tstate = wxPyBeginAllowThreads();
40950 (arg1)->SetAffirmativeButton(arg2);
40951
40952 wxPyEndAllowThreads(__tstate);
40953 if (PyErr_Occurred()) SWIG_fail;
40954 }
40955 Py_INCREF(Py_None); resultobj = Py_None;
40956 return resultobj;
40957 fail:
40958 return NULL;
40959 }
40960
40961
40962 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40963 PyObject *resultobj;
40964 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40965 wxButton *arg2 = (wxButton *) 0 ;
40966 PyObject * obj0 = 0 ;
40967 PyObject * obj1 = 0 ;
40968 char *kwnames[] = {
40969 (char *) "self",(char *) "button", NULL
40970 };
40971
40972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40974 if (SWIG_arg_fail(1)) SWIG_fail;
40975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40976 if (SWIG_arg_fail(2)) SWIG_fail;
40977 {
40978 PyThreadState* __tstate = wxPyBeginAllowThreads();
40979 (arg1)->SetNegativeButton(arg2);
40980
40981 wxPyEndAllowThreads(__tstate);
40982 if (PyErr_Occurred()) SWIG_fail;
40983 }
40984 Py_INCREF(Py_None); resultobj = Py_None;
40985 return resultobj;
40986 fail:
40987 return NULL;
40988 }
40989
40990
40991 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40992 PyObject *resultobj;
40993 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40994 wxButton *arg2 = (wxButton *) 0 ;
40995 PyObject * obj0 = 0 ;
40996 PyObject * obj1 = 0 ;
40997 char *kwnames[] = {
40998 (char *) "self",(char *) "button", NULL
40999 };
41000
41001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41003 if (SWIG_arg_fail(1)) SWIG_fail;
41004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41005 if (SWIG_arg_fail(2)) SWIG_fail;
41006 {
41007 PyThreadState* __tstate = wxPyBeginAllowThreads();
41008 (arg1)->SetCancelButton(arg2);
41009
41010 wxPyEndAllowThreads(__tstate);
41011 if (PyErr_Occurred()) SWIG_fail;
41012 }
41013 Py_INCREF(Py_None); resultobj = Py_None;
41014 return resultobj;
41015 fail:
41016 return NULL;
41017 }
41018
41019
41020 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41021 PyObject *resultobj;
41022 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41023 wxButton *result;
41024 PyObject * obj0 = 0 ;
41025 char *kwnames[] = {
41026 (char *) "self", NULL
41027 };
41028
41029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41031 if (SWIG_arg_fail(1)) SWIG_fail;
41032 {
41033 PyThreadState* __tstate = wxPyBeginAllowThreads();
41034 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41035
41036 wxPyEndAllowThreads(__tstate);
41037 if (PyErr_Occurred()) SWIG_fail;
41038 }
41039 {
41040 resultobj = wxPyMake_wxObject(result, 0);
41041 }
41042 return resultobj;
41043 fail:
41044 return NULL;
41045 }
41046
41047
41048 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41049 PyObject *resultobj;
41050 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41051 wxButton *result;
41052 PyObject * obj0 = 0 ;
41053 char *kwnames[] = {
41054 (char *) "self", NULL
41055 };
41056
41057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41059 if (SWIG_arg_fail(1)) SWIG_fail;
41060 {
41061 PyThreadState* __tstate = wxPyBeginAllowThreads();
41062 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41063
41064 wxPyEndAllowThreads(__tstate);
41065 if (PyErr_Occurred()) SWIG_fail;
41066 }
41067 {
41068 resultobj = wxPyMake_wxObject(result, 0);
41069 }
41070 return resultobj;
41071 fail:
41072 return NULL;
41073 }
41074
41075
41076 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41077 PyObject *resultobj;
41078 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41079 wxButton *result;
41080 PyObject * obj0 = 0 ;
41081 char *kwnames[] = {
41082 (char *) "self", NULL
41083 };
41084
41085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41087 if (SWIG_arg_fail(1)) SWIG_fail;
41088 {
41089 PyThreadState* __tstate = wxPyBeginAllowThreads();
41090 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41091
41092 wxPyEndAllowThreads(__tstate);
41093 if (PyErr_Occurred()) SWIG_fail;
41094 }
41095 {
41096 resultobj = wxPyMake_wxObject(result, 0);
41097 }
41098 return resultobj;
41099 fail:
41100 return NULL;
41101 }
41102
41103
41104 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41105 PyObject *resultobj;
41106 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41107 wxButton *result;
41108 PyObject * obj0 = 0 ;
41109 char *kwnames[] = {
41110 (char *) "self", NULL
41111 };
41112
41113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41115 if (SWIG_arg_fail(1)) SWIG_fail;
41116 {
41117 PyThreadState* __tstate = wxPyBeginAllowThreads();
41118 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41119
41120 wxPyEndAllowThreads(__tstate);
41121 if (PyErr_Occurred()) SWIG_fail;
41122 }
41123 {
41124 resultobj = wxPyMake_wxObject(result, 0);
41125 }
41126 return resultobj;
41127 fail:
41128 return NULL;
41129 }
41130
41131
41132 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41133 PyObject *resultobj;
41134 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41135 wxButton *result;
41136 PyObject * obj0 = 0 ;
41137 char *kwnames[] = {
41138 (char *) "self", NULL
41139 };
41140
41141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41143 if (SWIG_arg_fail(1)) SWIG_fail;
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41147
41148 wxPyEndAllowThreads(__tstate);
41149 if (PyErr_Occurred()) SWIG_fail;
41150 }
41151 {
41152 resultobj = wxPyMake_wxObject(result, 0);
41153 }
41154 return resultobj;
41155 fail:
41156 return NULL;
41157 }
41158
41159
41160 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41161 PyObject *obj;
41162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41163 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41164 Py_INCREF(obj);
41165 return Py_BuildValue((char *)"");
41166 }
41167 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41168 PyObject *resultobj;
41169 int arg1 = (int) 0 ;
41170 int arg2 = (int) 0 ;
41171 wxGBPosition *result;
41172 PyObject * obj0 = 0 ;
41173 PyObject * obj1 = 0 ;
41174 char *kwnames[] = {
41175 (char *) "row",(char *) "col", NULL
41176 };
41177
41178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41179 if (obj0) {
41180 {
41181 arg1 = (int)(SWIG_As_int(obj0));
41182 if (SWIG_arg_fail(1)) SWIG_fail;
41183 }
41184 }
41185 if (obj1) {
41186 {
41187 arg2 = (int)(SWIG_As_int(obj1));
41188 if (SWIG_arg_fail(2)) SWIG_fail;
41189 }
41190 }
41191 {
41192 PyThreadState* __tstate = wxPyBeginAllowThreads();
41193 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41194
41195 wxPyEndAllowThreads(__tstate);
41196 if (PyErr_Occurred()) SWIG_fail;
41197 }
41198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41199 return resultobj;
41200 fail:
41201 return NULL;
41202 }
41203
41204
41205 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41206 PyObject *resultobj;
41207 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41208 int result;
41209 PyObject * obj0 = 0 ;
41210 char *kwnames[] = {
41211 (char *) "self", NULL
41212 };
41213
41214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41216 if (SWIG_arg_fail(1)) SWIG_fail;
41217 {
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 result = (int)((wxGBPosition const *)arg1)->GetRow();
41220
41221 wxPyEndAllowThreads(__tstate);
41222 if (PyErr_Occurred()) SWIG_fail;
41223 }
41224 {
41225 resultobj = SWIG_From_int((int)(result));
41226 }
41227 return resultobj;
41228 fail:
41229 return NULL;
41230 }
41231
41232
41233 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41234 PyObject *resultobj;
41235 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41236 int result;
41237 PyObject * obj0 = 0 ;
41238 char *kwnames[] = {
41239 (char *) "self", NULL
41240 };
41241
41242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41244 if (SWIG_arg_fail(1)) SWIG_fail;
41245 {
41246 PyThreadState* __tstate = wxPyBeginAllowThreads();
41247 result = (int)((wxGBPosition const *)arg1)->GetCol();
41248
41249 wxPyEndAllowThreads(__tstate);
41250 if (PyErr_Occurred()) SWIG_fail;
41251 }
41252 {
41253 resultobj = SWIG_From_int((int)(result));
41254 }
41255 return resultobj;
41256 fail:
41257 return NULL;
41258 }
41259
41260
41261 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41262 PyObject *resultobj;
41263 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41264 int arg2 ;
41265 PyObject * obj0 = 0 ;
41266 PyObject * obj1 = 0 ;
41267 char *kwnames[] = {
41268 (char *) "self",(char *) "row", NULL
41269 };
41270
41271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41273 if (SWIG_arg_fail(1)) SWIG_fail;
41274 {
41275 arg2 = (int)(SWIG_As_int(obj1));
41276 if (SWIG_arg_fail(2)) SWIG_fail;
41277 }
41278 {
41279 PyThreadState* __tstate = wxPyBeginAllowThreads();
41280 (arg1)->SetRow(arg2);
41281
41282 wxPyEndAllowThreads(__tstate);
41283 if (PyErr_Occurred()) SWIG_fail;
41284 }
41285 Py_INCREF(Py_None); resultobj = Py_None;
41286 return resultobj;
41287 fail:
41288 return NULL;
41289 }
41290
41291
41292 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41293 PyObject *resultobj;
41294 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41295 int arg2 ;
41296 PyObject * obj0 = 0 ;
41297 PyObject * obj1 = 0 ;
41298 char *kwnames[] = {
41299 (char *) "self",(char *) "col", NULL
41300 };
41301
41302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41304 if (SWIG_arg_fail(1)) SWIG_fail;
41305 {
41306 arg2 = (int)(SWIG_As_int(obj1));
41307 if (SWIG_arg_fail(2)) SWIG_fail;
41308 }
41309 {
41310 PyThreadState* __tstate = wxPyBeginAllowThreads();
41311 (arg1)->SetCol(arg2);
41312
41313 wxPyEndAllowThreads(__tstate);
41314 if (PyErr_Occurred()) SWIG_fail;
41315 }
41316 Py_INCREF(Py_None); resultobj = Py_None;
41317 return resultobj;
41318 fail:
41319 return NULL;
41320 }
41321
41322
41323 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41324 PyObject *resultobj;
41325 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41326 wxGBPosition *arg2 = 0 ;
41327 bool result;
41328 wxGBPosition temp2 ;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 char *kwnames[] = {
41332 (char *) "self",(char *) "other", NULL
41333 };
41334
41335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41337 if (SWIG_arg_fail(1)) SWIG_fail;
41338 {
41339 arg2 = &temp2;
41340 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41341 }
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41345
41346 wxPyEndAllowThreads(__tstate);
41347 if (PyErr_Occurred()) SWIG_fail;
41348 }
41349 {
41350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41351 }
41352 return resultobj;
41353 fail:
41354 return NULL;
41355 }
41356
41357
41358 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41359 PyObject *resultobj;
41360 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41361 wxGBPosition *arg2 = 0 ;
41362 bool result;
41363 wxGBPosition temp2 ;
41364 PyObject * obj0 = 0 ;
41365 PyObject * obj1 = 0 ;
41366 char *kwnames[] = {
41367 (char *) "self",(char *) "other", NULL
41368 };
41369
41370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41372 if (SWIG_arg_fail(1)) SWIG_fail;
41373 {
41374 arg2 = &temp2;
41375 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41376 }
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41380
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 {
41385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41386 }
41387 return resultobj;
41388 fail:
41389 return NULL;
41390 }
41391
41392
41393 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj;
41395 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41396 int arg2 = (int) 0 ;
41397 int arg3 = (int) 0 ;
41398 PyObject * obj0 = 0 ;
41399 PyObject * obj1 = 0 ;
41400 PyObject * obj2 = 0 ;
41401 char *kwnames[] = {
41402 (char *) "self",(char *) "row",(char *) "col", NULL
41403 };
41404
41405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41407 if (SWIG_arg_fail(1)) SWIG_fail;
41408 if (obj1) {
41409 {
41410 arg2 = (int)(SWIG_As_int(obj1));
41411 if (SWIG_arg_fail(2)) SWIG_fail;
41412 }
41413 }
41414 if (obj2) {
41415 {
41416 arg3 = (int)(SWIG_As_int(obj2));
41417 if (SWIG_arg_fail(3)) SWIG_fail;
41418 }
41419 }
41420 {
41421 PyThreadState* __tstate = wxPyBeginAllowThreads();
41422 wxGBPosition_Set(arg1,arg2,arg3);
41423
41424 wxPyEndAllowThreads(__tstate);
41425 if (PyErr_Occurred()) SWIG_fail;
41426 }
41427 Py_INCREF(Py_None); resultobj = Py_None;
41428 return resultobj;
41429 fail:
41430 return NULL;
41431 }
41432
41433
41434 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41435 PyObject *resultobj;
41436 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41437 PyObject *result;
41438 PyObject * obj0 = 0 ;
41439 char *kwnames[] = {
41440 (char *) "self", NULL
41441 };
41442
41443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41445 if (SWIG_arg_fail(1)) SWIG_fail;
41446 {
41447 PyThreadState* __tstate = wxPyBeginAllowThreads();
41448 result = (PyObject *)wxGBPosition_Get(arg1);
41449
41450 wxPyEndAllowThreads(__tstate);
41451 if (PyErr_Occurred()) SWIG_fail;
41452 }
41453 resultobj = result;
41454 return resultobj;
41455 fail:
41456 return NULL;
41457 }
41458
41459
41460 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41461 PyObject *obj;
41462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41463 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41464 Py_INCREF(obj);
41465 return Py_BuildValue((char *)"");
41466 }
41467 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41468 PyObject *resultobj;
41469 int arg1 = (int) 1 ;
41470 int arg2 = (int) 1 ;
41471 wxGBSpan *result;
41472 PyObject * obj0 = 0 ;
41473 PyObject * obj1 = 0 ;
41474 char *kwnames[] = {
41475 (char *) "rowspan",(char *) "colspan", NULL
41476 };
41477
41478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41479 if (obj0) {
41480 {
41481 arg1 = (int)(SWIG_As_int(obj0));
41482 if (SWIG_arg_fail(1)) SWIG_fail;
41483 }
41484 }
41485 if (obj1) {
41486 {
41487 arg2 = (int)(SWIG_As_int(obj1));
41488 if (SWIG_arg_fail(2)) SWIG_fail;
41489 }
41490 }
41491 {
41492 PyThreadState* __tstate = wxPyBeginAllowThreads();
41493 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41494
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41506 PyObject *resultobj;
41507 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41508 int result;
41509 PyObject * obj0 = 0 ;
41510 char *kwnames[] = {
41511 (char *) "self", NULL
41512 };
41513
41514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41516 if (SWIG_arg_fail(1)) SWIG_fail;
41517 {
41518 PyThreadState* __tstate = wxPyBeginAllowThreads();
41519 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41520
41521 wxPyEndAllowThreads(__tstate);
41522 if (PyErr_Occurred()) SWIG_fail;
41523 }
41524 {
41525 resultobj = SWIG_From_int((int)(result));
41526 }
41527 return resultobj;
41528 fail:
41529 return NULL;
41530 }
41531
41532
41533 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41534 PyObject *resultobj;
41535 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41536 int result;
41537 PyObject * obj0 = 0 ;
41538 char *kwnames[] = {
41539 (char *) "self", NULL
41540 };
41541
41542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41544 if (SWIG_arg_fail(1)) SWIG_fail;
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41548
41549 wxPyEndAllowThreads(__tstate);
41550 if (PyErr_Occurred()) SWIG_fail;
41551 }
41552 {
41553 resultobj = SWIG_From_int((int)(result));
41554 }
41555 return resultobj;
41556 fail:
41557 return NULL;
41558 }
41559
41560
41561 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41562 PyObject *resultobj;
41563 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41564 int arg2 ;
41565 PyObject * obj0 = 0 ;
41566 PyObject * obj1 = 0 ;
41567 char *kwnames[] = {
41568 (char *) "self",(char *) "rowspan", NULL
41569 };
41570
41571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41573 if (SWIG_arg_fail(1)) SWIG_fail;
41574 {
41575 arg2 = (int)(SWIG_As_int(obj1));
41576 if (SWIG_arg_fail(2)) SWIG_fail;
41577 }
41578 {
41579 PyThreadState* __tstate = wxPyBeginAllowThreads();
41580 (arg1)->SetRowspan(arg2);
41581
41582 wxPyEndAllowThreads(__tstate);
41583 if (PyErr_Occurred()) SWIG_fail;
41584 }
41585 Py_INCREF(Py_None); resultobj = Py_None;
41586 return resultobj;
41587 fail:
41588 return NULL;
41589 }
41590
41591
41592 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41593 PyObject *resultobj;
41594 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41595 int arg2 ;
41596 PyObject * obj0 = 0 ;
41597 PyObject * obj1 = 0 ;
41598 char *kwnames[] = {
41599 (char *) "self",(char *) "colspan", NULL
41600 };
41601
41602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41604 if (SWIG_arg_fail(1)) SWIG_fail;
41605 {
41606 arg2 = (int)(SWIG_As_int(obj1));
41607 if (SWIG_arg_fail(2)) SWIG_fail;
41608 }
41609 {
41610 PyThreadState* __tstate = wxPyBeginAllowThreads();
41611 (arg1)->SetColspan(arg2);
41612
41613 wxPyEndAllowThreads(__tstate);
41614 if (PyErr_Occurred()) SWIG_fail;
41615 }
41616 Py_INCREF(Py_None); resultobj = Py_None;
41617 return resultobj;
41618 fail:
41619 return NULL;
41620 }
41621
41622
41623 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41624 PyObject *resultobj;
41625 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41626 wxGBSpan *arg2 = 0 ;
41627 bool result;
41628 wxGBSpan temp2 ;
41629 PyObject * obj0 = 0 ;
41630 PyObject * obj1 = 0 ;
41631 char *kwnames[] = {
41632 (char *) "self",(char *) "other", NULL
41633 };
41634
41635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41637 if (SWIG_arg_fail(1)) SWIG_fail;
41638 {
41639 arg2 = &temp2;
41640 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41641 }
41642 {
41643 PyThreadState* __tstate = wxPyBeginAllowThreads();
41644 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41645
41646 wxPyEndAllowThreads(__tstate);
41647 if (PyErr_Occurred()) SWIG_fail;
41648 }
41649 {
41650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41651 }
41652 return resultobj;
41653 fail:
41654 return NULL;
41655 }
41656
41657
41658 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41659 PyObject *resultobj;
41660 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41661 wxGBSpan *arg2 = 0 ;
41662 bool result;
41663 wxGBSpan temp2 ;
41664 PyObject * obj0 = 0 ;
41665 PyObject * obj1 = 0 ;
41666 char *kwnames[] = {
41667 (char *) "self",(char *) "other", NULL
41668 };
41669
41670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41672 if (SWIG_arg_fail(1)) SWIG_fail;
41673 {
41674 arg2 = &temp2;
41675 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41676 }
41677 {
41678 PyThreadState* __tstate = wxPyBeginAllowThreads();
41679 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41680
41681 wxPyEndAllowThreads(__tstate);
41682 if (PyErr_Occurred()) SWIG_fail;
41683 }
41684 {
41685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41686 }
41687 return resultobj;
41688 fail:
41689 return NULL;
41690 }
41691
41692
41693 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41694 PyObject *resultobj;
41695 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41696 int arg2 = (int) 1 ;
41697 int arg3 = (int) 1 ;
41698 PyObject * obj0 = 0 ;
41699 PyObject * obj1 = 0 ;
41700 PyObject * obj2 = 0 ;
41701 char *kwnames[] = {
41702 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41703 };
41704
41705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41707 if (SWIG_arg_fail(1)) SWIG_fail;
41708 if (obj1) {
41709 {
41710 arg2 = (int)(SWIG_As_int(obj1));
41711 if (SWIG_arg_fail(2)) SWIG_fail;
41712 }
41713 }
41714 if (obj2) {
41715 {
41716 arg3 = (int)(SWIG_As_int(obj2));
41717 if (SWIG_arg_fail(3)) SWIG_fail;
41718 }
41719 }
41720 {
41721 PyThreadState* __tstate = wxPyBeginAllowThreads();
41722 wxGBSpan_Set(arg1,arg2,arg3);
41723
41724 wxPyEndAllowThreads(__tstate);
41725 if (PyErr_Occurred()) SWIG_fail;
41726 }
41727 Py_INCREF(Py_None); resultobj = Py_None;
41728 return resultobj;
41729 fail:
41730 return NULL;
41731 }
41732
41733
41734 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41735 PyObject *resultobj;
41736 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41737 PyObject *result;
41738 PyObject * obj0 = 0 ;
41739 char *kwnames[] = {
41740 (char *) "self", NULL
41741 };
41742
41743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41745 if (SWIG_arg_fail(1)) SWIG_fail;
41746 {
41747 PyThreadState* __tstate = wxPyBeginAllowThreads();
41748 result = (PyObject *)wxGBSpan_Get(arg1);
41749
41750 wxPyEndAllowThreads(__tstate);
41751 if (PyErr_Occurred()) SWIG_fail;
41752 }
41753 resultobj = result;
41754 return resultobj;
41755 fail:
41756 return NULL;
41757 }
41758
41759
41760 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41761 PyObject *obj;
41762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41763 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41764 Py_INCREF(obj);
41765 return Py_BuildValue((char *)"");
41766 }
41767 static int _wrap_DefaultSpan_set(PyObject *) {
41768 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41769 return 1;
41770 }
41771
41772
41773 static PyObject *_wrap_DefaultSpan_get(void) {
41774 PyObject *pyobj;
41775
41776 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41777 return pyobj;
41778 }
41779
41780
41781 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41782 PyObject *resultobj;
41783 wxGBSizerItem *result;
41784 char *kwnames[] = {
41785 NULL
41786 };
41787
41788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41789 {
41790 PyThreadState* __tstate = wxPyBeginAllowThreads();
41791 result = (wxGBSizerItem *)new wxGBSizerItem();
41792
41793 wxPyEndAllowThreads(__tstate);
41794 if (PyErr_Occurred()) SWIG_fail;
41795 }
41796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41797 return resultobj;
41798 fail:
41799 return NULL;
41800 }
41801
41802
41803 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41804 PyObject *resultobj;
41805 wxWindow *arg1 = (wxWindow *) 0 ;
41806 wxGBPosition *arg2 = 0 ;
41807 wxGBSpan *arg3 = 0 ;
41808 int arg4 ;
41809 int arg5 ;
41810 PyObject *arg6 = (PyObject *) NULL ;
41811 wxGBSizerItem *result;
41812 wxGBPosition temp2 ;
41813 wxGBSpan temp3 ;
41814 PyObject * obj0 = 0 ;
41815 PyObject * obj1 = 0 ;
41816 PyObject * obj2 = 0 ;
41817 PyObject * obj3 = 0 ;
41818 PyObject * obj4 = 0 ;
41819 PyObject * obj5 = 0 ;
41820 char *kwnames[] = {
41821 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41822 };
41823
41824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41826 if (SWIG_arg_fail(1)) SWIG_fail;
41827 {
41828 arg2 = &temp2;
41829 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41830 }
41831 {
41832 arg3 = &temp3;
41833 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41834 }
41835 {
41836 arg4 = (int)(SWIG_As_int(obj3));
41837 if (SWIG_arg_fail(4)) SWIG_fail;
41838 }
41839 {
41840 arg5 = (int)(SWIG_As_int(obj4));
41841 if (SWIG_arg_fail(5)) SWIG_fail;
41842 }
41843 if (obj5) {
41844 arg6 = obj5;
41845 }
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41849
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41854 return resultobj;
41855 fail:
41856 return NULL;
41857 }
41858
41859
41860 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41861 PyObject *resultobj;
41862 wxSizer *arg1 = (wxSizer *) 0 ;
41863 wxGBPosition *arg2 = 0 ;
41864 wxGBSpan *arg3 = 0 ;
41865 int arg4 ;
41866 int arg5 ;
41867 PyObject *arg6 = (PyObject *) NULL ;
41868 wxGBSizerItem *result;
41869 wxGBPosition temp2 ;
41870 wxGBSpan temp3 ;
41871 PyObject * obj0 = 0 ;
41872 PyObject * obj1 = 0 ;
41873 PyObject * obj2 = 0 ;
41874 PyObject * obj3 = 0 ;
41875 PyObject * obj4 = 0 ;
41876 PyObject * obj5 = 0 ;
41877 char *kwnames[] = {
41878 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41879 };
41880
41881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41883 if (SWIG_arg_fail(1)) SWIG_fail;
41884 {
41885 arg2 = &temp2;
41886 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41887 }
41888 {
41889 arg3 = &temp3;
41890 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41891 }
41892 {
41893 arg4 = (int)(SWIG_As_int(obj3));
41894 if (SWIG_arg_fail(4)) SWIG_fail;
41895 }
41896 {
41897 arg5 = (int)(SWIG_As_int(obj4));
41898 if (SWIG_arg_fail(5)) SWIG_fail;
41899 }
41900 if (obj5) {
41901 arg6 = obj5;
41902 }
41903 {
41904 PyThreadState* __tstate = wxPyBeginAllowThreads();
41905 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41906
41907 wxPyEndAllowThreads(__tstate);
41908 if (PyErr_Occurred()) SWIG_fail;
41909 }
41910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41911 return resultobj;
41912 fail:
41913 return NULL;
41914 }
41915
41916
41917 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41918 PyObject *resultobj;
41919 int arg1 ;
41920 int arg2 ;
41921 wxGBPosition *arg3 = 0 ;
41922 wxGBSpan *arg4 = 0 ;
41923 int arg5 ;
41924 int arg6 ;
41925 PyObject *arg7 = (PyObject *) NULL ;
41926 wxGBSizerItem *result;
41927 wxGBPosition temp3 ;
41928 wxGBSpan temp4 ;
41929 PyObject * obj0 = 0 ;
41930 PyObject * obj1 = 0 ;
41931 PyObject * obj2 = 0 ;
41932 PyObject * obj3 = 0 ;
41933 PyObject * obj4 = 0 ;
41934 PyObject * obj5 = 0 ;
41935 PyObject * obj6 = 0 ;
41936 char *kwnames[] = {
41937 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41938 };
41939
41940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41941 {
41942 arg1 = (int)(SWIG_As_int(obj0));
41943 if (SWIG_arg_fail(1)) SWIG_fail;
41944 }
41945 {
41946 arg2 = (int)(SWIG_As_int(obj1));
41947 if (SWIG_arg_fail(2)) SWIG_fail;
41948 }
41949 {
41950 arg3 = &temp3;
41951 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41952 }
41953 {
41954 arg4 = &temp4;
41955 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41956 }
41957 {
41958 arg5 = (int)(SWIG_As_int(obj4));
41959 if (SWIG_arg_fail(5)) SWIG_fail;
41960 }
41961 {
41962 arg6 = (int)(SWIG_As_int(obj5));
41963 if (SWIG_arg_fail(6)) SWIG_fail;
41964 }
41965 if (obj6) {
41966 arg7 = obj6;
41967 }
41968 {
41969 PyThreadState* __tstate = wxPyBeginAllowThreads();
41970 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41971
41972 wxPyEndAllowThreads(__tstate);
41973 if (PyErr_Occurred()) SWIG_fail;
41974 }
41975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41983 PyObject *resultobj;
41984 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41985 wxGBPosition result;
41986 PyObject * obj0 = 0 ;
41987 char *kwnames[] = {
41988 (char *) "self", NULL
41989 };
41990
41991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41993 if (SWIG_arg_fail(1)) SWIG_fail;
41994 {
41995 PyThreadState* __tstate = wxPyBeginAllowThreads();
41996 result = ((wxGBSizerItem const *)arg1)->GetPos();
41997
41998 wxPyEndAllowThreads(__tstate);
41999 if (PyErr_Occurred()) SWIG_fail;
42000 }
42001 {
42002 wxGBPosition * resultptr;
42003 resultptr = new wxGBPosition((wxGBPosition &)(result));
42004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42005 }
42006 return resultobj;
42007 fail:
42008 return NULL;
42009 }
42010
42011
42012 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42013 PyObject *resultobj;
42014 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42015 wxGBSpan result;
42016 PyObject * obj0 = 0 ;
42017 char *kwnames[] = {
42018 (char *) "self", NULL
42019 };
42020
42021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42023 if (SWIG_arg_fail(1)) SWIG_fail;
42024 {
42025 PyThreadState* __tstate = wxPyBeginAllowThreads();
42026 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42027
42028 wxPyEndAllowThreads(__tstate);
42029 if (PyErr_Occurred()) SWIG_fail;
42030 }
42031 {
42032 wxGBSpan * resultptr;
42033 resultptr = new wxGBSpan((wxGBSpan &)(result));
42034 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42035 }
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42043 PyObject *resultobj;
42044 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42045 wxGBPosition *arg2 = 0 ;
42046 bool result;
42047 wxGBPosition temp2 ;
42048 PyObject * obj0 = 0 ;
42049 PyObject * obj1 = 0 ;
42050 char *kwnames[] = {
42051 (char *) "self",(char *) "pos", NULL
42052 };
42053
42054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42056 if (SWIG_arg_fail(1)) SWIG_fail;
42057 {
42058 arg2 = &temp2;
42059 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42060 }
42061 {
42062 PyThreadState* __tstate = wxPyBeginAllowThreads();
42063 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42064
42065 wxPyEndAllowThreads(__tstate);
42066 if (PyErr_Occurred()) SWIG_fail;
42067 }
42068 {
42069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42070 }
42071 return resultobj;
42072 fail:
42073 return NULL;
42074 }
42075
42076
42077 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42078 PyObject *resultobj;
42079 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42080 wxGBSpan *arg2 = 0 ;
42081 bool result;
42082 wxGBSpan temp2 ;
42083 PyObject * obj0 = 0 ;
42084 PyObject * obj1 = 0 ;
42085 char *kwnames[] = {
42086 (char *) "self",(char *) "span", NULL
42087 };
42088
42089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42091 if (SWIG_arg_fail(1)) SWIG_fail;
42092 {
42093 arg2 = &temp2;
42094 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42095 }
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42099
42100 wxPyEndAllowThreads(__tstate);
42101 if (PyErr_Occurred()) SWIG_fail;
42102 }
42103 {
42104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42105 }
42106 return resultobj;
42107 fail:
42108 return NULL;
42109 }
42110
42111
42112 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42113 PyObject *resultobj;
42114 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42115 wxGBSizerItem *arg2 = 0 ;
42116 bool result;
42117 PyObject * obj0 = 0 ;
42118 PyObject * obj1 = 0 ;
42119 char *kwnames[] = {
42120 (char *) "self",(char *) "other", NULL
42121 };
42122
42123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42125 if (SWIG_arg_fail(1)) SWIG_fail;
42126 {
42127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42128 if (SWIG_arg_fail(2)) SWIG_fail;
42129 if (arg2 == NULL) {
42130 SWIG_null_ref("wxGBSizerItem");
42131 }
42132 if (SWIG_arg_fail(2)) SWIG_fail;
42133 }
42134 {
42135 PyThreadState* __tstate = wxPyBeginAllowThreads();
42136 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42137
42138 wxPyEndAllowThreads(__tstate);
42139 if (PyErr_Occurred()) SWIG_fail;
42140 }
42141 {
42142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42143 }
42144 return resultobj;
42145 fail:
42146 return NULL;
42147 }
42148
42149
42150 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42151 PyObject *resultobj;
42152 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42153 wxGBPosition *arg2 = 0 ;
42154 wxGBSpan *arg3 = 0 ;
42155 bool result;
42156 wxGBPosition temp2 ;
42157 wxGBSpan temp3 ;
42158 PyObject * obj0 = 0 ;
42159 PyObject * obj1 = 0 ;
42160 PyObject * obj2 = 0 ;
42161 char *kwnames[] = {
42162 (char *) "self",(char *) "pos",(char *) "span", NULL
42163 };
42164
42165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42167 if (SWIG_arg_fail(1)) SWIG_fail;
42168 {
42169 arg2 = &temp2;
42170 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42171 }
42172 {
42173 arg3 = &temp3;
42174 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42175 }
42176 {
42177 PyThreadState* __tstate = wxPyBeginAllowThreads();
42178 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42179
42180 wxPyEndAllowThreads(__tstate);
42181 if (PyErr_Occurred()) SWIG_fail;
42182 }
42183 {
42184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42185 }
42186 return resultobj;
42187 fail:
42188 return NULL;
42189 }
42190
42191
42192 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42193 PyObject *resultobj;
42194 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42195 wxGBPosition result;
42196 PyObject * obj0 = 0 ;
42197 char *kwnames[] = {
42198 (char *) "self", NULL
42199 };
42200
42201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42203 if (SWIG_arg_fail(1)) SWIG_fail;
42204 {
42205 PyThreadState* __tstate = wxPyBeginAllowThreads();
42206 result = wxGBSizerItem_GetEndPos(arg1);
42207
42208 wxPyEndAllowThreads(__tstate);
42209 if (PyErr_Occurred()) SWIG_fail;
42210 }
42211 {
42212 wxGBPosition * resultptr;
42213 resultptr = new wxGBPosition((wxGBPosition &)(result));
42214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42215 }
42216 return resultobj;
42217 fail:
42218 return NULL;
42219 }
42220
42221
42222 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42223 PyObject *resultobj;
42224 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42225 wxGridBagSizer *result;
42226 PyObject * obj0 = 0 ;
42227 char *kwnames[] = {
42228 (char *) "self", NULL
42229 };
42230
42231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42233 if (SWIG_arg_fail(1)) SWIG_fail;
42234 {
42235 PyThreadState* __tstate = wxPyBeginAllowThreads();
42236 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42237
42238 wxPyEndAllowThreads(__tstate);
42239 if (PyErr_Occurred()) SWIG_fail;
42240 }
42241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42242 return resultobj;
42243 fail:
42244 return NULL;
42245 }
42246
42247
42248 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42249 PyObject *resultobj;
42250 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42251 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42252 PyObject * obj0 = 0 ;
42253 PyObject * obj1 = 0 ;
42254 char *kwnames[] = {
42255 (char *) "self",(char *) "sizer", NULL
42256 };
42257
42258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42260 if (SWIG_arg_fail(1)) SWIG_fail;
42261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42262 if (SWIG_arg_fail(2)) SWIG_fail;
42263 {
42264 PyThreadState* __tstate = wxPyBeginAllowThreads();
42265 (arg1)->SetGBSizer(arg2);
42266
42267 wxPyEndAllowThreads(__tstate);
42268 if (PyErr_Occurred()) SWIG_fail;
42269 }
42270 Py_INCREF(Py_None); resultobj = Py_None;
42271 return resultobj;
42272 fail:
42273 return NULL;
42274 }
42275
42276
42277 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42278 PyObject *obj;
42279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42280 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42281 Py_INCREF(obj);
42282 return Py_BuildValue((char *)"");
42283 }
42284 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42285 PyObject *resultobj;
42286 int arg1 = (int) 0 ;
42287 int arg2 = (int) 0 ;
42288 wxGridBagSizer *result;
42289 PyObject * obj0 = 0 ;
42290 PyObject * obj1 = 0 ;
42291 char *kwnames[] = {
42292 (char *) "vgap",(char *) "hgap", NULL
42293 };
42294
42295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42296 if (obj0) {
42297 {
42298 arg1 = (int)(SWIG_As_int(obj0));
42299 if (SWIG_arg_fail(1)) SWIG_fail;
42300 }
42301 }
42302 if (obj1) {
42303 {
42304 arg2 = (int)(SWIG_As_int(obj1));
42305 if (SWIG_arg_fail(2)) SWIG_fail;
42306 }
42307 }
42308 {
42309 PyThreadState* __tstate = wxPyBeginAllowThreads();
42310 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42311
42312 wxPyEndAllowThreads(__tstate);
42313 if (PyErr_Occurred()) SWIG_fail;
42314 }
42315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42316 return resultobj;
42317 fail:
42318 return NULL;
42319 }
42320
42321
42322 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42323 PyObject *resultobj;
42324 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42325 PyObject *arg2 = (PyObject *) 0 ;
42326 wxGBPosition *arg3 = 0 ;
42327 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42328 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42329 int arg5 = (int) 0 ;
42330 int arg6 = (int) 0 ;
42331 PyObject *arg7 = (PyObject *) NULL ;
42332 wxGBSizerItem *result;
42333 wxGBPosition temp3 ;
42334 wxGBSpan temp4 ;
42335 PyObject * obj0 = 0 ;
42336 PyObject * obj1 = 0 ;
42337 PyObject * obj2 = 0 ;
42338 PyObject * obj3 = 0 ;
42339 PyObject * obj4 = 0 ;
42340 PyObject * obj5 = 0 ;
42341 PyObject * obj6 = 0 ;
42342 char *kwnames[] = {
42343 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42344 };
42345
42346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42348 if (SWIG_arg_fail(1)) SWIG_fail;
42349 arg2 = obj1;
42350 {
42351 arg3 = &temp3;
42352 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42353 }
42354 if (obj3) {
42355 {
42356 arg4 = &temp4;
42357 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42358 }
42359 }
42360 if (obj4) {
42361 {
42362 arg5 = (int)(SWIG_As_int(obj4));
42363 if (SWIG_arg_fail(5)) SWIG_fail;
42364 }
42365 }
42366 if (obj5) {
42367 {
42368 arg6 = (int)(SWIG_As_int(obj5));
42369 if (SWIG_arg_fail(6)) SWIG_fail;
42370 }
42371 }
42372 if (obj6) {
42373 arg7 = obj6;
42374 }
42375 {
42376 PyThreadState* __tstate = wxPyBeginAllowThreads();
42377 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42378
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42383 return resultobj;
42384 fail:
42385 return NULL;
42386 }
42387
42388
42389 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42390 PyObject *resultobj;
42391 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42392 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42393 wxGBSizerItem *result;
42394 PyObject * obj0 = 0 ;
42395 PyObject * obj1 = 0 ;
42396 char *kwnames[] = {
42397 (char *) "self",(char *) "item", NULL
42398 };
42399
42400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42402 if (SWIG_arg_fail(1)) SWIG_fail;
42403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42404 if (SWIG_arg_fail(2)) SWIG_fail;
42405 {
42406 PyThreadState* __tstate = wxPyBeginAllowThreads();
42407 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42408
42409 wxPyEndAllowThreads(__tstate);
42410 if (PyErr_Occurred()) SWIG_fail;
42411 }
42412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42413 return resultobj;
42414 fail:
42415 return NULL;
42416 }
42417
42418
42419 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42420 PyObject *resultobj;
42421 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42422 int arg2 ;
42423 int arg3 ;
42424 wxSize result;
42425 PyObject * obj0 = 0 ;
42426 PyObject * obj1 = 0 ;
42427 PyObject * obj2 = 0 ;
42428 char *kwnames[] = {
42429 (char *) "self",(char *) "row",(char *) "col", NULL
42430 };
42431
42432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42434 if (SWIG_arg_fail(1)) SWIG_fail;
42435 {
42436 arg2 = (int)(SWIG_As_int(obj1));
42437 if (SWIG_arg_fail(2)) SWIG_fail;
42438 }
42439 {
42440 arg3 = (int)(SWIG_As_int(obj2));
42441 if (SWIG_arg_fail(3)) SWIG_fail;
42442 }
42443 {
42444 PyThreadState* __tstate = wxPyBeginAllowThreads();
42445 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42446
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 {
42451 wxSize * resultptr;
42452 resultptr = new wxSize((wxSize &)(result));
42453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42454 }
42455 return resultobj;
42456 fail:
42457 return NULL;
42458 }
42459
42460
42461 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42462 PyObject *resultobj;
42463 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42464 wxSize result;
42465 PyObject * obj0 = 0 ;
42466 char *kwnames[] = {
42467 (char *) "self", NULL
42468 };
42469
42470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42472 if (SWIG_arg_fail(1)) SWIG_fail;
42473 {
42474 PyThreadState* __tstate = wxPyBeginAllowThreads();
42475 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42476
42477 wxPyEndAllowThreads(__tstate);
42478 if (PyErr_Occurred()) SWIG_fail;
42479 }
42480 {
42481 wxSize * resultptr;
42482 resultptr = new wxSize((wxSize &)(result));
42483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42484 }
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42492 PyObject *resultobj;
42493 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42494 wxSize *arg2 = 0 ;
42495 wxSize temp2 ;
42496 PyObject * obj0 = 0 ;
42497 PyObject * obj1 = 0 ;
42498 char *kwnames[] = {
42499 (char *) "self",(char *) "sz", NULL
42500 };
42501
42502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42504 if (SWIG_arg_fail(1)) SWIG_fail;
42505 {
42506 arg2 = &temp2;
42507 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42508 }
42509 {
42510 PyThreadState* __tstate = wxPyBeginAllowThreads();
42511 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42512
42513 wxPyEndAllowThreads(__tstate);
42514 if (PyErr_Occurred()) SWIG_fail;
42515 }
42516 Py_INCREF(Py_None); resultobj = Py_None;
42517 return resultobj;
42518 fail:
42519 return NULL;
42520 }
42521
42522
42523 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42524 PyObject *resultobj;
42525 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42526 wxWindow *arg2 = (wxWindow *) 0 ;
42527 wxGBPosition result;
42528 PyObject * obj0 = 0 ;
42529 PyObject * obj1 = 0 ;
42530
42531 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42533 if (SWIG_arg_fail(1)) SWIG_fail;
42534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42535 if (SWIG_arg_fail(2)) SWIG_fail;
42536 {
42537 PyThreadState* __tstate = wxPyBeginAllowThreads();
42538 result = (arg1)->GetItemPosition(arg2);
42539
42540 wxPyEndAllowThreads(__tstate);
42541 if (PyErr_Occurred()) SWIG_fail;
42542 }
42543 {
42544 wxGBPosition * resultptr;
42545 resultptr = new wxGBPosition((wxGBPosition &)(result));
42546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42547 }
42548 return resultobj;
42549 fail:
42550 return NULL;
42551 }
42552
42553
42554 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42555 PyObject *resultobj;
42556 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42557 wxSizer *arg2 = (wxSizer *) 0 ;
42558 wxGBPosition result;
42559 PyObject * obj0 = 0 ;
42560 PyObject * obj1 = 0 ;
42561
42562 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42564 if (SWIG_arg_fail(1)) SWIG_fail;
42565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42566 if (SWIG_arg_fail(2)) SWIG_fail;
42567 {
42568 PyThreadState* __tstate = wxPyBeginAllowThreads();
42569 result = (arg1)->GetItemPosition(arg2);
42570
42571 wxPyEndAllowThreads(__tstate);
42572 if (PyErr_Occurred()) SWIG_fail;
42573 }
42574 {
42575 wxGBPosition * resultptr;
42576 resultptr = new wxGBPosition((wxGBPosition &)(result));
42577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42578 }
42579 return resultobj;
42580 fail:
42581 return NULL;
42582 }
42583
42584
42585 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42586 PyObject *resultobj;
42587 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42588 size_t arg2 ;
42589 wxGBPosition result;
42590 PyObject * obj0 = 0 ;
42591 PyObject * obj1 = 0 ;
42592
42593 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42595 if (SWIG_arg_fail(1)) SWIG_fail;
42596 {
42597 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42598 if (SWIG_arg_fail(2)) SWIG_fail;
42599 }
42600 {
42601 PyThreadState* __tstate = wxPyBeginAllowThreads();
42602 result = (arg1)->GetItemPosition(arg2);
42603
42604 wxPyEndAllowThreads(__tstate);
42605 if (PyErr_Occurred()) SWIG_fail;
42606 }
42607 {
42608 wxGBPosition * resultptr;
42609 resultptr = new wxGBPosition((wxGBPosition &)(result));
42610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42611 }
42612 return resultobj;
42613 fail:
42614 return NULL;
42615 }
42616
42617
42618 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42619 int argc;
42620 PyObject *argv[3];
42621 int ii;
42622
42623 argc = PyObject_Length(args);
42624 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42625 argv[ii] = PyTuple_GetItem(args,ii);
42626 }
42627 if (argc == 2) {
42628 int _v;
42629 {
42630 void *ptr;
42631 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42632 _v = 0;
42633 PyErr_Clear();
42634 } else {
42635 _v = 1;
42636 }
42637 }
42638 if (_v) {
42639 {
42640 void *ptr;
42641 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42642 _v = 0;
42643 PyErr_Clear();
42644 } else {
42645 _v = 1;
42646 }
42647 }
42648 if (_v) {
42649 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42650 }
42651 }
42652 }
42653 if (argc == 2) {
42654 int _v;
42655 {
42656 void *ptr;
42657 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42658 _v = 0;
42659 PyErr_Clear();
42660 } else {
42661 _v = 1;
42662 }
42663 }
42664 if (_v) {
42665 {
42666 void *ptr;
42667 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42668 _v = 0;
42669 PyErr_Clear();
42670 } else {
42671 _v = 1;
42672 }
42673 }
42674 if (_v) {
42675 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42676 }
42677 }
42678 }
42679 if (argc == 2) {
42680 int _v;
42681 {
42682 void *ptr;
42683 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42684 _v = 0;
42685 PyErr_Clear();
42686 } else {
42687 _v = 1;
42688 }
42689 }
42690 if (_v) {
42691 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42692 if (_v) {
42693 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42694 }
42695 }
42696 }
42697
42698 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42699 return NULL;
42700 }
42701
42702
42703 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42704 PyObject *resultobj;
42705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42706 wxWindow *arg2 = (wxWindow *) 0 ;
42707 wxGBPosition *arg3 = 0 ;
42708 bool result;
42709 wxGBPosition temp3 ;
42710 PyObject * obj0 = 0 ;
42711 PyObject * obj1 = 0 ;
42712 PyObject * obj2 = 0 ;
42713
42714 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42716 if (SWIG_arg_fail(1)) SWIG_fail;
42717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42718 if (SWIG_arg_fail(2)) SWIG_fail;
42719 {
42720 arg3 = &temp3;
42721 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42722 }
42723 {
42724 PyThreadState* __tstate = wxPyBeginAllowThreads();
42725 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42726
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 {
42731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42732 }
42733 return resultobj;
42734 fail:
42735 return NULL;
42736 }
42737
42738
42739 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42740 PyObject *resultobj;
42741 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42742 wxSizer *arg2 = (wxSizer *) 0 ;
42743 wxGBPosition *arg3 = 0 ;
42744 bool result;
42745 wxGBPosition temp3 ;
42746 PyObject * obj0 = 0 ;
42747 PyObject * obj1 = 0 ;
42748 PyObject * obj2 = 0 ;
42749
42750 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42752 if (SWIG_arg_fail(1)) SWIG_fail;
42753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42754 if (SWIG_arg_fail(2)) SWIG_fail;
42755 {
42756 arg3 = &temp3;
42757 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42758 }
42759 {
42760 PyThreadState* __tstate = wxPyBeginAllowThreads();
42761 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42762
42763 wxPyEndAllowThreads(__tstate);
42764 if (PyErr_Occurred()) SWIG_fail;
42765 }
42766 {
42767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42768 }
42769 return resultobj;
42770 fail:
42771 return NULL;
42772 }
42773
42774
42775 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42776 PyObject *resultobj;
42777 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42778 size_t arg2 ;
42779 wxGBPosition *arg3 = 0 ;
42780 bool result;
42781 wxGBPosition temp3 ;
42782 PyObject * obj0 = 0 ;
42783 PyObject * obj1 = 0 ;
42784 PyObject * obj2 = 0 ;
42785
42786 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42788 if (SWIG_arg_fail(1)) SWIG_fail;
42789 {
42790 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42791 if (SWIG_arg_fail(2)) SWIG_fail;
42792 }
42793 {
42794 arg3 = &temp3;
42795 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42796 }
42797 {
42798 PyThreadState* __tstate = wxPyBeginAllowThreads();
42799 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42800
42801 wxPyEndAllowThreads(__tstate);
42802 if (PyErr_Occurred()) SWIG_fail;
42803 }
42804 {
42805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42806 }
42807 return resultobj;
42808 fail:
42809 return NULL;
42810 }
42811
42812
42813 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42814 int argc;
42815 PyObject *argv[4];
42816 int ii;
42817
42818 argc = PyObject_Length(args);
42819 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42820 argv[ii] = PyTuple_GetItem(args,ii);
42821 }
42822 if (argc == 3) {
42823 int _v;
42824 {
42825 void *ptr;
42826 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42827 _v = 0;
42828 PyErr_Clear();
42829 } else {
42830 _v = 1;
42831 }
42832 }
42833 if (_v) {
42834 {
42835 void *ptr;
42836 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42837 _v = 0;
42838 PyErr_Clear();
42839 } else {
42840 _v = 1;
42841 }
42842 }
42843 if (_v) {
42844 {
42845 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42846 }
42847 if (_v) {
42848 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42849 }
42850 }
42851 }
42852 }
42853 if (argc == 3) {
42854 int _v;
42855 {
42856 void *ptr;
42857 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42858 _v = 0;
42859 PyErr_Clear();
42860 } else {
42861 _v = 1;
42862 }
42863 }
42864 if (_v) {
42865 {
42866 void *ptr;
42867 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42868 _v = 0;
42869 PyErr_Clear();
42870 } else {
42871 _v = 1;
42872 }
42873 }
42874 if (_v) {
42875 {
42876 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42877 }
42878 if (_v) {
42879 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42880 }
42881 }
42882 }
42883 }
42884 if (argc == 3) {
42885 int _v;
42886 {
42887 void *ptr;
42888 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42889 _v = 0;
42890 PyErr_Clear();
42891 } else {
42892 _v = 1;
42893 }
42894 }
42895 if (_v) {
42896 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42897 if (_v) {
42898 {
42899 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42900 }
42901 if (_v) {
42902 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42903 }
42904 }
42905 }
42906 }
42907
42908 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42909 return NULL;
42910 }
42911
42912
42913 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42914 PyObject *resultobj;
42915 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42916 wxWindow *arg2 = (wxWindow *) 0 ;
42917 wxGBSpan result;
42918 PyObject * obj0 = 0 ;
42919 PyObject * obj1 = 0 ;
42920
42921 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42923 if (SWIG_arg_fail(1)) SWIG_fail;
42924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42925 if (SWIG_arg_fail(2)) SWIG_fail;
42926 {
42927 PyThreadState* __tstate = wxPyBeginAllowThreads();
42928 result = (arg1)->GetItemSpan(arg2);
42929
42930 wxPyEndAllowThreads(__tstate);
42931 if (PyErr_Occurred()) SWIG_fail;
42932 }
42933 {
42934 wxGBSpan * resultptr;
42935 resultptr = new wxGBSpan((wxGBSpan &)(result));
42936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42937 }
42938 return resultobj;
42939 fail:
42940 return NULL;
42941 }
42942
42943
42944 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42945 PyObject *resultobj;
42946 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42947 wxSizer *arg2 = (wxSizer *) 0 ;
42948 wxGBSpan result;
42949 PyObject * obj0 = 0 ;
42950 PyObject * obj1 = 0 ;
42951
42952 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42954 if (SWIG_arg_fail(1)) SWIG_fail;
42955 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42956 if (SWIG_arg_fail(2)) SWIG_fail;
42957 {
42958 PyThreadState* __tstate = wxPyBeginAllowThreads();
42959 result = (arg1)->GetItemSpan(arg2);
42960
42961 wxPyEndAllowThreads(__tstate);
42962 if (PyErr_Occurred()) SWIG_fail;
42963 }
42964 {
42965 wxGBSpan * resultptr;
42966 resultptr = new wxGBSpan((wxGBSpan &)(result));
42967 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42968 }
42969 return resultobj;
42970 fail:
42971 return NULL;
42972 }
42973
42974
42975 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42976 PyObject *resultobj;
42977 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42978 size_t arg2 ;
42979 wxGBSpan result;
42980 PyObject * obj0 = 0 ;
42981 PyObject * obj1 = 0 ;
42982
42983 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42985 if (SWIG_arg_fail(1)) SWIG_fail;
42986 {
42987 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42988 if (SWIG_arg_fail(2)) SWIG_fail;
42989 }
42990 {
42991 PyThreadState* __tstate = wxPyBeginAllowThreads();
42992 result = (arg1)->GetItemSpan(arg2);
42993
42994 wxPyEndAllowThreads(__tstate);
42995 if (PyErr_Occurred()) SWIG_fail;
42996 }
42997 {
42998 wxGBSpan * resultptr;
42999 resultptr = new wxGBSpan((wxGBSpan &)(result));
43000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43001 }
43002 return resultobj;
43003 fail:
43004 return NULL;
43005 }
43006
43007
43008 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43009 int argc;
43010 PyObject *argv[3];
43011 int ii;
43012
43013 argc = PyObject_Length(args);
43014 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43015 argv[ii] = PyTuple_GetItem(args,ii);
43016 }
43017 if (argc == 2) {
43018 int _v;
43019 {
43020 void *ptr;
43021 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43022 _v = 0;
43023 PyErr_Clear();
43024 } else {
43025 _v = 1;
43026 }
43027 }
43028 if (_v) {
43029 {
43030 void *ptr;
43031 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43032 _v = 0;
43033 PyErr_Clear();
43034 } else {
43035 _v = 1;
43036 }
43037 }
43038 if (_v) {
43039 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43040 }
43041 }
43042 }
43043 if (argc == 2) {
43044 int _v;
43045 {
43046 void *ptr;
43047 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43048 _v = 0;
43049 PyErr_Clear();
43050 } else {
43051 _v = 1;
43052 }
43053 }
43054 if (_v) {
43055 {
43056 void *ptr;
43057 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43058 _v = 0;
43059 PyErr_Clear();
43060 } else {
43061 _v = 1;
43062 }
43063 }
43064 if (_v) {
43065 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43066 }
43067 }
43068 }
43069 if (argc == 2) {
43070 int _v;
43071 {
43072 void *ptr;
43073 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43074 _v = 0;
43075 PyErr_Clear();
43076 } else {
43077 _v = 1;
43078 }
43079 }
43080 if (_v) {
43081 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43082 if (_v) {
43083 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43084 }
43085 }
43086 }
43087
43088 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43089 return NULL;
43090 }
43091
43092
43093 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43094 PyObject *resultobj;
43095 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43096 wxWindow *arg2 = (wxWindow *) 0 ;
43097 wxGBSpan *arg3 = 0 ;
43098 bool result;
43099 wxGBSpan temp3 ;
43100 PyObject * obj0 = 0 ;
43101 PyObject * obj1 = 0 ;
43102 PyObject * obj2 = 0 ;
43103
43104 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43106 if (SWIG_arg_fail(1)) SWIG_fail;
43107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43108 if (SWIG_arg_fail(2)) SWIG_fail;
43109 {
43110 arg3 = &temp3;
43111 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43112 }
43113 {
43114 PyThreadState* __tstate = wxPyBeginAllowThreads();
43115 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43116
43117 wxPyEndAllowThreads(__tstate);
43118 if (PyErr_Occurred()) SWIG_fail;
43119 }
43120 {
43121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43122 }
43123 return resultobj;
43124 fail:
43125 return NULL;
43126 }
43127
43128
43129 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43130 PyObject *resultobj;
43131 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43132 wxSizer *arg2 = (wxSizer *) 0 ;
43133 wxGBSpan *arg3 = 0 ;
43134 bool result;
43135 wxGBSpan temp3 ;
43136 PyObject * obj0 = 0 ;
43137 PyObject * obj1 = 0 ;
43138 PyObject * obj2 = 0 ;
43139
43140 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43142 if (SWIG_arg_fail(1)) SWIG_fail;
43143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43144 if (SWIG_arg_fail(2)) SWIG_fail;
43145 {
43146 arg3 = &temp3;
43147 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43148 }
43149 {
43150 PyThreadState* __tstate = wxPyBeginAllowThreads();
43151 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43152
43153 wxPyEndAllowThreads(__tstate);
43154 if (PyErr_Occurred()) SWIG_fail;
43155 }
43156 {
43157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43158 }
43159 return resultobj;
43160 fail:
43161 return NULL;
43162 }
43163
43164
43165 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43166 PyObject *resultobj;
43167 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43168 size_t arg2 ;
43169 wxGBSpan *arg3 = 0 ;
43170 bool result;
43171 wxGBSpan temp3 ;
43172 PyObject * obj0 = 0 ;
43173 PyObject * obj1 = 0 ;
43174 PyObject * obj2 = 0 ;
43175
43176 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43178 if (SWIG_arg_fail(1)) SWIG_fail;
43179 {
43180 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43181 if (SWIG_arg_fail(2)) SWIG_fail;
43182 }
43183 {
43184 arg3 = &temp3;
43185 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43186 }
43187 {
43188 PyThreadState* __tstate = wxPyBeginAllowThreads();
43189 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43190
43191 wxPyEndAllowThreads(__tstate);
43192 if (PyErr_Occurred()) SWIG_fail;
43193 }
43194 {
43195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43196 }
43197 return resultobj;
43198 fail:
43199 return NULL;
43200 }
43201
43202
43203 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43204 int argc;
43205 PyObject *argv[4];
43206 int ii;
43207
43208 argc = PyObject_Length(args);
43209 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43210 argv[ii] = PyTuple_GetItem(args,ii);
43211 }
43212 if (argc == 3) {
43213 int _v;
43214 {
43215 void *ptr;
43216 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43217 _v = 0;
43218 PyErr_Clear();
43219 } else {
43220 _v = 1;
43221 }
43222 }
43223 if (_v) {
43224 {
43225 void *ptr;
43226 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43227 _v = 0;
43228 PyErr_Clear();
43229 } else {
43230 _v = 1;
43231 }
43232 }
43233 if (_v) {
43234 {
43235 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43236 }
43237 if (_v) {
43238 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43239 }
43240 }
43241 }
43242 }
43243 if (argc == 3) {
43244 int _v;
43245 {
43246 void *ptr;
43247 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43248 _v = 0;
43249 PyErr_Clear();
43250 } else {
43251 _v = 1;
43252 }
43253 }
43254 if (_v) {
43255 {
43256 void *ptr;
43257 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43258 _v = 0;
43259 PyErr_Clear();
43260 } else {
43261 _v = 1;
43262 }
43263 }
43264 if (_v) {
43265 {
43266 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43267 }
43268 if (_v) {
43269 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43270 }
43271 }
43272 }
43273 }
43274 if (argc == 3) {
43275 int _v;
43276 {
43277 void *ptr;
43278 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43279 _v = 0;
43280 PyErr_Clear();
43281 } else {
43282 _v = 1;
43283 }
43284 }
43285 if (_v) {
43286 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43287 if (_v) {
43288 {
43289 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43290 }
43291 if (_v) {
43292 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43293 }
43294 }
43295 }
43296 }
43297
43298 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43299 return NULL;
43300 }
43301
43302
43303 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43304 PyObject *resultobj;
43305 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43306 wxWindow *arg2 = (wxWindow *) 0 ;
43307 wxGBSizerItem *result;
43308 PyObject * obj0 = 0 ;
43309 PyObject * obj1 = 0 ;
43310
43311 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43313 if (SWIG_arg_fail(1)) SWIG_fail;
43314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43315 if (SWIG_arg_fail(2)) SWIG_fail;
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43319
43320 wxPyEndAllowThreads(__tstate);
43321 if (PyErr_Occurred()) SWIG_fail;
43322 }
43323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43324 return resultobj;
43325 fail:
43326 return NULL;
43327 }
43328
43329
43330 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43331 PyObject *resultobj;
43332 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43333 wxSizer *arg2 = (wxSizer *) 0 ;
43334 wxGBSizerItem *result;
43335 PyObject * obj0 = 0 ;
43336 PyObject * obj1 = 0 ;
43337
43338 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43340 if (SWIG_arg_fail(1)) SWIG_fail;
43341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43342 if (SWIG_arg_fail(2)) SWIG_fail;
43343 {
43344 PyThreadState* __tstate = wxPyBeginAllowThreads();
43345 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43346
43347 wxPyEndAllowThreads(__tstate);
43348 if (PyErr_Occurred()) SWIG_fail;
43349 }
43350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43351 return resultobj;
43352 fail:
43353 return NULL;
43354 }
43355
43356
43357 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43358 int argc;
43359 PyObject *argv[3];
43360 int ii;
43361
43362 argc = PyObject_Length(args);
43363 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43364 argv[ii] = PyTuple_GetItem(args,ii);
43365 }
43366 if (argc == 2) {
43367 int _v;
43368 {
43369 void *ptr;
43370 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43371 _v = 0;
43372 PyErr_Clear();
43373 } else {
43374 _v = 1;
43375 }
43376 }
43377 if (_v) {
43378 {
43379 void *ptr;
43380 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43381 _v = 0;
43382 PyErr_Clear();
43383 } else {
43384 _v = 1;
43385 }
43386 }
43387 if (_v) {
43388 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43389 }
43390 }
43391 }
43392 if (argc == 2) {
43393 int _v;
43394 {
43395 void *ptr;
43396 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43397 _v = 0;
43398 PyErr_Clear();
43399 } else {
43400 _v = 1;
43401 }
43402 }
43403 if (_v) {
43404 {
43405 void *ptr;
43406 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43407 _v = 0;
43408 PyErr_Clear();
43409 } else {
43410 _v = 1;
43411 }
43412 }
43413 if (_v) {
43414 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43415 }
43416 }
43417 }
43418
43419 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43420 return NULL;
43421 }
43422
43423
43424 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43425 PyObject *resultobj;
43426 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43427 wxGBPosition *arg2 = 0 ;
43428 wxGBSizerItem *result;
43429 wxGBPosition temp2 ;
43430 PyObject * obj0 = 0 ;
43431 PyObject * obj1 = 0 ;
43432 char *kwnames[] = {
43433 (char *) "self",(char *) "pos", NULL
43434 };
43435
43436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43438 if (SWIG_arg_fail(1)) SWIG_fail;
43439 {
43440 arg2 = &temp2;
43441 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43442 }
43443 {
43444 PyThreadState* __tstate = wxPyBeginAllowThreads();
43445 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43446
43447 wxPyEndAllowThreads(__tstate);
43448 if (PyErr_Occurred()) SWIG_fail;
43449 }
43450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43451 return resultobj;
43452 fail:
43453 return NULL;
43454 }
43455
43456
43457 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43458 PyObject *resultobj;
43459 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43460 wxPoint *arg2 = 0 ;
43461 wxGBSizerItem *result;
43462 wxPoint temp2 ;
43463 PyObject * obj0 = 0 ;
43464 PyObject * obj1 = 0 ;
43465 char *kwnames[] = {
43466 (char *) "self",(char *) "pt", NULL
43467 };
43468
43469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43471 if (SWIG_arg_fail(1)) SWIG_fail;
43472 {
43473 arg2 = &temp2;
43474 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43475 }
43476 {
43477 PyThreadState* __tstate = wxPyBeginAllowThreads();
43478 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43479
43480 wxPyEndAllowThreads(__tstate);
43481 if (PyErr_Occurred()) SWIG_fail;
43482 }
43483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj;
43492 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43493 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43494 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43495 bool result;
43496 PyObject * obj0 = 0 ;
43497 PyObject * obj1 = 0 ;
43498 PyObject * obj2 = 0 ;
43499 char *kwnames[] = {
43500 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43501 };
43502
43503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43505 if (SWIG_arg_fail(1)) SWIG_fail;
43506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43507 if (SWIG_arg_fail(2)) SWIG_fail;
43508 if (obj2) {
43509 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43510 if (SWIG_arg_fail(3)) SWIG_fail;
43511 }
43512 {
43513 PyThreadState* __tstate = wxPyBeginAllowThreads();
43514 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43515
43516 wxPyEndAllowThreads(__tstate);
43517 if (PyErr_Occurred()) SWIG_fail;
43518 }
43519 {
43520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43521 }
43522 return resultobj;
43523 fail:
43524 return NULL;
43525 }
43526
43527
43528 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43529 PyObject *resultobj;
43530 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43531 wxGBPosition *arg2 = 0 ;
43532 wxGBSpan *arg3 = 0 ;
43533 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43534 bool result;
43535 wxGBPosition temp2 ;
43536 wxGBSpan temp3 ;
43537 PyObject * obj0 = 0 ;
43538 PyObject * obj1 = 0 ;
43539 PyObject * obj2 = 0 ;
43540 PyObject * obj3 = 0 ;
43541 char *kwnames[] = {
43542 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43543 };
43544
43545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43547 if (SWIG_arg_fail(1)) SWIG_fail;
43548 {
43549 arg2 = &temp2;
43550 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43551 }
43552 {
43553 arg3 = &temp3;
43554 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43555 }
43556 if (obj3) {
43557 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43558 if (SWIG_arg_fail(4)) SWIG_fail;
43559 }
43560 {
43561 PyThreadState* __tstate = wxPyBeginAllowThreads();
43562 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43563
43564 wxPyEndAllowThreads(__tstate);
43565 if (PyErr_Occurred()) SWIG_fail;
43566 }
43567 {
43568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43569 }
43570 return resultobj;
43571 fail:
43572 return NULL;
43573 }
43574
43575
43576 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43577 PyObject *obj;
43578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43579 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43580 Py_INCREF(obj);
43581 return Py_BuildValue((char *)"");
43582 }
43583 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43584 PyObject *resultobj;
43585 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43586 wxRelationship arg2 ;
43587 wxWindow *arg3 = (wxWindow *) 0 ;
43588 wxEdge arg4 ;
43589 int arg5 = (int) 0 ;
43590 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43591 PyObject * obj0 = 0 ;
43592 PyObject * obj1 = 0 ;
43593 PyObject * obj2 = 0 ;
43594 PyObject * obj3 = 0 ;
43595 PyObject * obj4 = 0 ;
43596 PyObject * obj5 = 0 ;
43597 char *kwnames[] = {
43598 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43599 };
43600
43601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43603 if (SWIG_arg_fail(1)) SWIG_fail;
43604 {
43605 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43606 if (SWIG_arg_fail(2)) SWIG_fail;
43607 }
43608 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43609 if (SWIG_arg_fail(3)) SWIG_fail;
43610 {
43611 arg4 = (wxEdge)(SWIG_As_int(obj3));
43612 if (SWIG_arg_fail(4)) SWIG_fail;
43613 }
43614 if (obj4) {
43615 {
43616 arg5 = (int)(SWIG_As_int(obj4));
43617 if (SWIG_arg_fail(5)) SWIG_fail;
43618 }
43619 }
43620 if (obj5) {
43621 {
43622 arg6 = (int)(SWIG_As_int(obj5));
43623 if (SWIG_arg_fail(6)) SWIG_fail;
43624 }
43625 }
43626 {
43627 PyThreadState* __tstate = wxPyBeginAllowThreads();
43628 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43629
43630 wxPyEndAllowThreads(__tstate);
43631 if (PyErr_Occurred()) SWIG_fail;
43632 }
43633 Py_INCREF(Py_None); resultobj = Py_None;
43634 return resultobj;
43635 fail:
43636 return NULL;
43637 }
43638
43639
43640 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43641 PyObject *resultobj;
43642 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43643 wxWindow *arg2 = (wxWindow *) 0 ;
43644 int arg3 = (int) 0 ;
43645 PyObject * obj0 = 0 ;
43646 PyObject * obj1 = 0 ;
43647 PyObject * obj2 = 0 ;
43648 char *kwnames[] = {
43649 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43650 };
43651
43652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43654 if (SWIG_arg_fail(1)) SWIG_fail;
43655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43656 if (SWIG_arg_fail(2)) SWIG_fail;
43657 if (obj2) {
43658 {
43659 arg3 = (int)(SWIG_As_int(obj2));
43660 if (SWIG_arg_fail(3)) SWIG_fail;
43661 }
43662 }
43663 {
43664 PyThreadState* __tstate = wxPyBeginAllowThreads();
43665 (arg1)->LeftOf(arg2,arg3);
43666
43667 wxPyEndAllowThreads(__tstate);
43668 if (PyErr_Occurred()) SWIG_fail;
43669 }
43670 Py_INCREF(Py_None); resultobj = Py_None;
43671 return resultobj;
43672 fail:
43673 return NULL;
43674 }
43675
43676
43677 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43678 PyObject *resultobj;
43679 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43680 wxWindow *arg2 = (wxWindow *) 0 ;
43681 int arg3 = (int) 0 ;
43682 PyObject * obj0 = 0 ;
43683 PyObject * obj1 = 0 ;
43684 PyObject * obj2 = 0 ;
43685 char *kwnames[] = {
43686 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43687 };
43688
43689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43691 if (SWIG_arg_fail(1)) SWIG_fail;
43692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43693 if (SWIG_arg_fail(2)) SWIG_fail;
43694 if (obj2) {
43695 {
43696 arg3 = (int)(SWIG_As_int(obj2));
43697 if (SWIG_arg_fail(3)) SWIG_fail;
43698 }
43699 }
43700 {
43701 PyThreadState* __tstate = wxPyBeginAllowThreads();
43702 (arg1)->RightOf(arg2,arg3);
43703
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 Py_INCREF(Py_None); resultobj = Py_None;
43708 return resultobj;
43709 fail:
43710 return NULL;
43711 }
43712
43713
43714 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43715 PyObject *resultobj;
43716 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43717 wxWindow *arg2 = (wxWindow *) 0 ;
43718 int arg3 = (int) 0 ;
43719 PyObject * obj0 = 0 ;
43720 PyObject * obj1 = 0 ;
43721 PyObject * obj2 = 0 ;
43722 char *kwnames[] = {
43723 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43724 };
43725
43726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43728 if (SWIG_arg_fail(1)) SWIG_fail;
43729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43730 if (SWIG_arg_fail(2)) SWIG_fail;
43731 if (obj2) {
43732 {
43733 arg3 = (int)(SWIG_As_int(obj2));
43734 if (SWIG_arg_fail(3)) SWIG_fail;
43735 }
43736 }
43737 {
43738 PyThreadState* __tstate = wxPyBeginAllowThreads();
43739 (arg1)->Above(arg2,arg3);
43740
43741 wxPyEndAllowThreads(__tstate);
43742 if (PyErr_Occurred()) SWIG_fail;
43743 }
43744 Py_INCREF(Py_None); resultobj = Py_None;
43745 return resultobj;
43746 fail:
43747 return NULL;
43748 }
43749
43750
43751 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43752 PyObject *resultobj;
43753 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43754 wxWindow *arg2 = (wxWindow *) 0 ;
43755 int arg3 = (int) 0 ;
43756 PyObject * obj0 = 0 ;
43757 PyObject * obj1 = 0 ;
43758 PyObject * obj2 = 0 ;
43759 char *kwnames[] = {
43760 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43761 };
43762
43763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43765 if (SWIG_arg_fail(1)) SWIG_fail;
43766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43767 if (SWIG_arg_fail(2)) SWIG_fail;
43768 if (obj2) {
43769 {
43770 arg3 = (int)(SWIG_As_int(obj2));
43771 if (SWIG_arg_fail(3)) SWIG_fail;
43772 }
43773 }
43774 {
43775 PyThreadState* __tstate = wxPyBeginAllowThreads();
43776 (arg1)->Below(arg2,arg3);
43777
43778 wxPyEndAllowThreads(__tstate);
43779 if (PyErr_Occurred()) SWIG_fail;
43780 }
43781 Py_INCREF(Py_None); resultobj = Py_None;
43782 return resultobj;
43783 fail:
43784 return NULL;
43785 }
43786
43787
43788 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43789 PyObject *resultobj;
43790 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43791 wxWindow *arg2 = (wxWindow *) 0 ;
43792 wxEdge arg3 ;
43793 int arg4 = (int) 0 ;
43794 PyObject * obj0 = 0 ;
43795 PyObject * obj1 = 0 ;
43796 PyObject * obj2 = 0 ;
43797 PyObject * obj3 = 0 ;
43798 char *kwnames[] = {
43799 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43800 };
43801
43802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43804 if (SWIG_arg_fail(1)) SWIG_fail;
43805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43806 if (SWIG_arg_fail(2)) SWIG_fail;
43807 {
43808 arg3 = (wxEdge)(SWIG_As_int(obj2));
43809 if (SWIG_arg_fail(3)) SWIG_fail;
43810 }
43811 if (obj3) {
43812 {
43813 arg4 = (int)(SWIG_As_int(obj3));
43814 if (SWIG_arg_fail(4)) SWIG_fail;
43815 }
43816 }
43817 {
43818 PyThreadState* __tstate = wxPyBeginAllowThreads();
43819 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43820
43821 wxPyEndAllowThreads(__tstate);
43822 if (PyErr_Occurred()) SWIG_fail;
43823 }
43824 Py_INCREF(Py_None); resultobj = Py_None;
43825 return resultobj;
43826 fail:
43827 return NULL;
43828 }
43829
43830
43831 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43832 PyObject *resultobj;
43833 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43834 wxWindow *arg2 = (wxWindow *) 0 ;
43835 wxEdge arg3 ;
43836 int arg4 ;
43837 PyObject * obj0 = 0 ;
43838 PyObject * obj1 = 0 ;
43839 PyObject * obj2 = 0 ;
43840 PyObject * obj3 = 0 ;
43841 char *kwnames[] = {
43842 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43843 };
43844
43845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43847 if (SWIG_arg_fail(1)) SWIG_fail;
43848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43849 if (SWIG_arg_fail(2)) SWIG_fail;
43850 {
43851 arg3 = (wxEdge)(SWIG_As_int(obj2));
43852 if (SWIG_arg_fail(3)) SWIG_fail;
43853 }
43854 {
43855 arg4 = (int)(SWIG_As_int(obj3));
43856 if (SWIG_arg_fail(4)) SWIG_fail;
43857 }
43858 {
43859 PyThreadState* __tstate = wxPyBeginAllowThreads();
43860 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43861
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 Py_INCREF(Py_None); resultobj = Py_None;
43866 return resultobj;
43867 fail:
43868 return NULL;
43869 }
43870
43871
43872 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43873 PyObject *resultobj;
43874 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43875 int arg2 ;
43876 PyObject * obj0 = 0 ;
43877 PyObject * obj1 = 0 ;
43878 char *kwnames[] = {
43879 (char *) "self",(char *) "val", NULL
43880 };
43881
43882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43884 if (SWIG_arg_fail(1)) SWIG_fail;
43885 {
43886 arg2 = (int)(SWIG_As_int(obj1));
43887 if (SWIG_arg_fail(2)) SWIG_fail;
43888 }
43889 {
43890 PyThreadState* __tstate = wxPyBeginAllowThreads();
43891 (arg1)->Absolute(arg2);
43892
43893 wxPyEndAllowThreads(__tstate);
43894 if (PyErr_Occurred()) SWIG_fail;
43895 }
43896 Py_INCREF(Py_None); resultobj = Py_None;
43897 return resultobj;
43898 fail:
43899 return NULL;
43900 }
43901
43902
43903 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43904 PyObject *resultobj;
43905 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43906 PyObject * obj0 = 0 ;
43907 char *kwnames[] = {
43908 (char *) "self", NULL
43909 };
43910
43911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43913 if (SWIG_arg_fail(1)) SWIG_fail;
43914 {
43915 PyThreadState* __tstate = wxPyBeginAllowThreads();
43916 (arg1)->Unconstrained();
43917
43918 wxPyEndAllowThreads(__tstate);
43919 if (PyErr_Occurred()) SWIG_fail;
43920 }
43921 Py_INCREF(Py_None); resultobj = Py_None;
43922 return resultobj;
43923 fail:
43924 return NULL;
43925 }
43926
43927
43928 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43929 PyObject *resultobj;
43930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43931 PyObject * obj0 = 0 ;
43932 char *kwnames[] = {
43933 (char *) "self", NULL
43934 };
43935
43936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43938 if (SWIG_arg_fail(1)) SWIG_fail;
43939 {
43940 PyThreadState* __tstate = wxPyBeginAllowThreads();
43941 (arg1)->AsIs();
43942
43943 wxPyEndAllowThreads(__tstate);
43944 if (PyErr_Occurred()) SWIG_fail;
43945 }
43946 Py_INCREF(Py_None); resultobj = Py_None;
43947 return resultobj;
43948 fail:
43949 return NULL;
43950 }
43951
43952
43953 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43954 PyObject *resultobj;
43955 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43956 wxWindow *result;
43957 PyObject * obj0 = 0 ;
43958 char *kwnames[] = {
43959 (char *) "self", NULL
43960 };
43961
43962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43964 if (SWIG_arg_fail(1)) SWIG_fail;
43965 {
43966 PyThreadState* __tstate = wxPyBeginAllowThreads();
43967 result = (wxWindow *)(arg1)->GetOtherWindow();
43968
43969 wxPyEndAllowThreads(__tstate);
43970 if (PyErr_Occurred()) SWIG_fail;
43971 }
43972 {
43973 resultobj = wxPyMake_wxObject(result, 0);
43974 }
43975 return resultobj;
43976 fail:
43977 return NULL;
43978 }
43979
43980
43981 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43982 PyObject *resultobj;
43983 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43984 wxEdge result;
43985 PyObject * obj0 = 0 ;
43986 char *kwnames[] = {
43987 (char *) "self", NULL
43988 };
43989
43990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43992 if (SWIG_arg_fail(1)) SWIG_fail;
43993 {
43994 PyThreadState* __tstate = wxPyBeginAllowThreads();
43995 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43996
43997 wxPyEndAllowThreads(__tstate);
43998 if (PyErr_Occurred()) SWIG_fail;
43999 }
44000 resultobj = SWIG_From_int((result));
44001 return resultobj;
44002 fail:
44003 return NULL;
44004 }
44005
44006
44007 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44008 PyObject *resultobj;
44009 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44010 wxEdge arg2 ;
44011 PyObject * obj0 = 0 ;
44012 PyObject * obj1 = 0 ;
44013 char *kwnames[] = {
44014 (char *) "self",(char *) "which", NULL
44015 };
44016
44017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44019 if (SWIG_arg_fail(1)) SWIG_fail;
44020 {
44021 arg2 = (wxEdge)(SWIG_As_int(obj1));
44022 if (SWIG_arg_fail(2)) SWIG_fail;
44023 }
44024 {
44025 PyThreadState* __tstate = wxPyBeginAllowThreads();
44026 (arg1)->SetEdge((wxEdge )arg2);
44027
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 Py_INCREF(Py_None); resultobj = Py_None;
44032 return resultobj;
44033 fail:
44034 return NULL;
44035 }
44036
44037
44038 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44039 PyObject *resultobj;
44040 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44041 int arg2 ;
44042 PyObject * obj0 = 0 ;
44043 PyObject * obj1 = 0 ;
44044 char *kwnames[] = {
44045 (char *) "self",(char *) "v", NULL
44046 };
44047
44048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44050 if (SWIG_arg_fail(1)) SWIG_fail;
44051 {
44052 arg2 = (int)(SWIG_As_int(obj1));
44053 if (SWIG_arg_fail(2)) SWIG_fail;
44054 }
44055 {
44056 PyThreadState* __tstate = wxPyBeginAllowThreads();
44057 (arg1)->SetValue(arg2);
44058
44059 wxPyEndAllowThreads(__tstate);
44060 if (PyErr_Occurred()) SWIG_fail;
44061 }
44062 Py_INCREF(Py_None); resultobj = Py_None;
44063 return resultobj;
44064 fail:
44065 return NULL;
44066 }
44067
44068
44069 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44070 PyObject *resultobj;
44071 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44072 int result;
44073 PyObject * obj0 = 0 ;
44074 char *kwnames[] = {
44075 (char *) "self", NULL
44076 };
44077
44078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44080 if (SWIG_arg_fail(1)) SWIG_fail;
44081 {
44082 PyThreadState* __tstate = wxPyBeginAllowThreads();
44083 result = (int)(arg1)->GetMargin();
44084
44085 wxPyEndAllowThreads(__tstate);
44086 if (PyErr_Occurred()) SWIG_fail;
44087 }
44088 {
44089 resultobj = SWIG_From_int((int)(result));
44090 }
44091 return resultobj;
44092 fail:
44093 return NULL;
44094 }
44095
44096
44097 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44098 PyObject *resultobj;
44099 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44100 int arg2 ;
44101 PyObject * obj0 = 0 ;
44102 PyObject * obj1 = 0 ;
44103 char *kwnames[] = {
44104 (char *) "self",(char *) "m", NULL
44105 };
44106
44107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44109 if (SWIG_arg_fail(1)) SWIG_fail;
44110 {
44111 arg2 = (int)(SWIG_As_int(obj1));
44112 if (SWIG_arg_fail(2)) SWIG_fail;
44113 }
44114 {
44115 PyThreadState* __tstate = wxPyBeginAllowThreads();
44116 (arg1)->SetMargin(arg2);
44117
44118 wxPyEndAllowThreads(__tstate);
44119 if (PyErr_Occurred()) SWIG_fail;
44120 }
44121 Py_INCREF(Py_None); resultobj = Py_None;
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44129 PyObject *resultobj;
44130 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44131 int result;
44132 PyObject * obj0 = 0 ;
44133 char *kwnames[] = {
44134 (char *) "self", NULL
44135 };
44136
44137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44139 if (SWIG_arg_fail(1)) SWIG_fail;
44140 {
44141 PyThreadState* __tstate = wxPyBeginAllowThreads();
44142 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44143
44144 wxPyEndAllowThreads(__tstate);
44145 if (PyErr_Occurred()) SWIG_fail;
44146 }
44147 {
44148 resultobj = SWIG_From_int((int)(result));
44149 }
44150 return resultobj;
44151 fail:
44152 return NULL;
44153 }
44154
44155
44156 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44157 PyObject *resultobj;
44158 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44159 int result;
44160 PyObject * obj0 = 0 ;
44161 char *kwnames[] = {
44162 (char *) "self", NULL
44163 };
44164
44165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44167 if (SWIG_arg_fail(1)) SWIG_fail;
44168 {
44169 PyThreadState* __tstate = wxPyBeginAllowThreads();
44170 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44171
44172 wxPyEndAllowThreads(__tstate);
44173 if (PyErr_Occurred()) SWIG_fail;
44174 }
44175 {
44176 resultobj = SWIG_From_int((int)(result));
44177 }
44178 return resultobj;
44179 fail:
44180 return NULL;
44181 }
44182
44183
44184 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44185 PyObject *resultobj;
44186 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44187 int result;
44188 PyObject * obj0 = 0 ;
44189 char *kwnames[] = {
44190 (char *) "self", NULL
44191 };
44192
44193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44195 if (SWIG_arg_fail(1)) SWIG_fail;
44196 {
44197 PyThreadState* __tstate = wxPyBeginAllowThreads();
44198 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44199
44200 wxPyEndAllowThreads(__tstate);
44201 if (PyErr_Occurred()) SWIG_fail;
44202 }
44203 {
44204 resultobj = SWIG_From_int((int)(result));
44205 }
44206 return resultobj;
44207 fail:
44208 return NULL;
44209 }
44210
44211
44212 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44213 PyObject *resultobj;
44214 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44215 bool result;
44216 PyObject * obj0 = 0 ;
44217 char *kwnames[] = {
44218 (char *) "self", NULL
44219 };
44220
44221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44223 if (SWIG_arg_fail(1)) SWIG_fail;
44224 {
44225 PyThreadState* __tstate = wxPyBeginAllowThreads();
44226 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44227
44228 wxPyEndAllowThreads(__tstate);
44229 if (PyErr_Occurred()) SWIG_fail;
44230 }
44231 {
44232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44233 }
44234 return resultobj;
44235 fail:
44236 return NULL;
44237 }
44238
44239
44240 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44241 PyObject *resultobj;
44242 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44243 bool arg2 ;
44244 PyObject * obj0 = 0 ;
44245 PyObject * obj1 = 0 ;
44246 char *kwnames[] = {
44247 (char *) "self",(char *) "d", NULL
44248 };
44249
44250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44252 if (SWIG_arg_fail(1)) SWIG_fail;
44253 {
44254 arg2 = (bool)(SWIG_As_bool(obj1));
44255 if (SWIG_arg_fail(2)) SWIG_fail;
44256 }
44257 {
44258 PyThreadState* __tstate = wxPyBeginAllowThreads();
44259 (arg1)->SetDone(arg2);
44260
44261 wxPyEndAllowThreads(__tstate);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 }
44264 Py_INCREF(Py_None); resultobj = Py_None;
44265 return resultobj;
44266 fail:
44267 return NULL;
44268 }
44269
44270
44271 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44272 PyObject *resultobj;
44273 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44274 wxRelationship result;
44275 PyObject * obj0 = 0 ;
44276 char *kwnames[] = {
44277 (char *) "self", NULL
44278 };
44279
44280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44282 if (SWIG_arg_fail(1)) SWIG_fail;
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 result = (wxRelationship)(arg1)->GetRelationship();
44286
44287 wxPyEndAllowThreads(__tstate);
44288 if (PyErr_Occurred()) SWIG_fail;
44289 }
44290 resultobj = SWIG_From_int((result));
44291 return resultobj;
44292 fail:
44293 return NULL;
44294 }
44295
44296
44297 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44298 PyObject *resultobj;
44299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44300 wxRelationship arg2 ;
44301 PyObject * obj0 = 0 ;
44302 PyObject * obj1 = 0 ;
44303 char *kwnames[] = {
44304 (char *) "self",(char *) "r", NULL
44305 };
44306
44307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44309 if (SWIG_arg_fail(1)) SWIG_fail;
44310 {
44311 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44312 if (SWIG_arg_fail(2)) SWIG_fail;
44313 }
44314 {
44315 PyThreadState* __tstate = wxPyBeginAllowThreads();
44316 (arg1)->SetRelationship((wxRelationship )arg2);
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_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44329 PyObject *resultobj;
44330 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44331 wxWindow *arg2 = (wxWindow *) 0 ;
44332 bool result;
44333 PyObject * obj0 = 0 ;
44334 PyObject * obj1 = 0 ;
44335 char *kwnames[] = {
44336 (char *) "self",(char *) "otherW", NULL
44337 };
44338
44339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44341 if (SWIG_arg_fail(1)) SWIG_fail;
44342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44343 if (SWIG_arg_fail(2)) SWIG_fail;
44344 {
44345 PyThreadState* __tstate = wxPyBeginAllowThreads();
44346 result = (bool)(arg1)->ResetIfWin(arg2);
44347
44348 wxPyEndAllowThreads(__tstate);
44349 if (PyErr_Occurred()) SWIG_fail;
44350 }
44351 {
44352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44353 }
44354 return resultobj;
44355 fail:
44356 return NULL;
44357 }
44358
44359
44360 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44361 PyObject *resultobj;
44362 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44363 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44364 wxWindow *arg3 = (wxWindow *) 0 ;
44365 bool result;
44366 PyObject * obj0 = 0 ;
44367 PyObject * obj1 = 0 ;
44368 PyObject * obj2 = 0 ;
44369 char *kwnames[] = {
44370 (char *) "self",(char *) "constraints",(char *) "win", NULL
44371 };
44372
44373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44375 if (SWIG_arg_fail(1)) SWIG_fail;
44376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44377 if (SWIG_arg_fail(2)) SWIG_fail;
44378 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44379 if (SWIG_arg_fail(3)) SWIG_fail;
44380 {
44381 PyThreadState* __tstate = wxPyBeginAllowThreads();
44382 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44383
44384 wxPyEndAllowThreads(__tstate);
44385 if (PyErr_Occurred()) SWIG_fail;
44386 }
44387 {
44388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44389 }
44390 return resultobj;
44391 fail:
44392 return NULL;
44393 }
44394
44395
44396 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44397 PyObject *resultobj;
44398 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44399 wxEdge arg2 ;
44400 wxWindow *arg3 = (wxWindow *) 0 ;
44401 wxWindow *arg4 = (wxWindow *) 0 ;
44402 int result;
44403 PyObject * obj0 = 0 ;
44404 PyObject * obj1 = 0 ;
44405 PyObject * obj2 = 0 ;
44406 PyObject * obj3 = 0 ;
44407 char *kwnames[] = {
44408 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44409 };
44410
44411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44413 if (SWIG_arg_fail(1)) SWIG_fail;
44414 {
44415 arg2 = (wxEdge)(SWIG_As_int(obj1));
44416 if (SWIG_arg_fail(2)) SWIG_fail;
44417 }
44418 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44419 if (SWIG_arg_fail(3)) SWIG_fail;
44420 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44421 if (SWIG_arg_fail(4)) SWIG_fail;
44422 {
44423 PyThreadState* __tstate = wxPyBeginAllowThreads();
44424 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44425
44426 wxPyEndAllowThreads(__tstate);
44427 if (PyErr_Occurred()) SWIG_fail;
44428 }
44429 {
44430 resultobj = SWIG_From_int((int)(result));
44431 }
44432 return resultobj;
44433 fail:
44434 return NULL;
44435 }
44436
44437
44438 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44439 PyObject *obj;
44440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44441 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44442 Py_INCREF(obj);
44443 return Py_BuildValue((char *)"");
44444 }
44445 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44446 PyObject *resultobj;
44447 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44448 wxIndividualLayoutConstraint *result;
44449 PyObject * obj0 = 0 ;
44450 char *kwnames[] = {
44451 (char *) "self", NULL
44452 };
44453
44454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44456 if (SWIG_arg_fail(1)) SWIG_fail;
44457 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44458
44459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44460 return resultobj;
44461 fail:
44462 return NULL;
44463 }
44464
44465
44466 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44467 PyObject *resultobj;
44468 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44469 wxIndividualLayoutConstraint *result;
44470 PyObject * obj0 = 0 ;
44471 char *kwnames[] = {
44472 (char *) "self", NULL
44473 };
44474
44475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44477 if (SWIG_arg_fail(1)) SWIG_fail;
44478 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44479
44480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44481 return resultobj;
44482 fail:
44483 return NULL;
44484 }
44485
44486
44487 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44488 PyObject *resultobj;
44489 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44490 wxIndividualLayoutConstraint *result;
44491 PyObject * obj0 = 0 ;
44492 char *kwnames[] = {
44493 (char *) "self", NULL
44494 };
44495
44496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44498 if (SWIG_arg_fail(1)) SWIG_fail;
44499 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44500
44501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44502 return resultobj;
44503 fail:
44504 return NULL;
44505 }
44506
44507
44508 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44509 PyObject *resultobj;
44510 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44511 wxIndividualLayoutConstraint *result;
44512 PyObject * obj0 = 0 ;
44513 char *kwnames[] = {
44514 (char *) "self", NULL
44515 };
44516
44517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44519 if (SWIG_arg_fail(1)) SWIG_fail;
44520 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44521
44522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44523 return resultobj;
44524 fail:
44525 return NULL;
44526 }
44527
44528
44529 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44530 PyObject *resultobj;
44531 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44532 wxIndividualLayoutConstraint *result;
44533 PyObject * obj0 = 0 ;
44534 char *kwnames[] = {
44535 (char *) "self", NULL
44536 };
44537
44538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44540 if (SWIG_arg_fail(1)) SWIG_fail;
44541 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44542
44543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj;
44552 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44553 wxIndividualLayoutConstraint *result;
44554 PyObject * obj0 = 0 ;
44555 char *kwnames[] = {
44556 (char *) "self", NULL
44557 };
44558
44559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44561 if (SWIG_arg_fail(1)) SWIG_fail;
44562 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44563
44564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44565 return resultobj;
44566 fail:
44567 return NULL;
44568 }
44569
44570
44571 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44572 PyObject *resultobj;
44573 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44574 wxIndividualLayoutConstraint *result;
44575 PyObject * obj0 = 0 ;
44576 char *kwnames[] = {
44577 (char *) "self", NULL
44578 };
44579
44580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44582 if (SWIG_arg_fail(1)) SWIG_fail;
44583 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44584
44585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44586 return resultobj;
44587 fail:
44588 return NULL;
44589 }
44590
44591
44592 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44593 PyObject *resultobj;
44594 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44595 wxIndividualLayoutConstraint *result;
44596 PyObject * obj0 = 0 ;
44597 char *kwnames[] = {
44598 (char *) "self", NULL
44599 };
44600
44601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44603 if (SWIG_arg_fail(1)) SWIG_fail;
44604 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44605
44606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44607 return resultobj;
44608 fail:
44609 return NULL;
44610 }
44611
44612
44613 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44614 PyObject *resultobj;
44615 wxLayoutConstraints *result;
44616 char *kwnames[] = {
44617 NULL
44618 };
44619
44620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44621 {
44622 PyThreadState* __tstate = wxPyBeginAllowThreads();
44623 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44624
44625 wxPyEndAllowThreads(__tstate);
44626 if (PyErr_Occurred()) SWIG_fail;
44627 }
44628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44629 return resultobj;
44630 fail:
44631 return NULL;
44632 }
44633
44634
44635 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44636 PyObject *resultobj;
44637 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44638 wxWindow *arg2 = (wxWindow *) 0 ;
44639 int *arg3 = (int *) 0 ;
44640 bool result;
44641 int temp3 ;
44642 int res3 = 0 ;
44643 PyObject * obj0 = 0 ;
44644 PyObject * obj1 = 0 ;
44645 char *kwnames[] = {
44646 (char *) "self",(char *) "win", NULL
44647 };
44648
44649 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44652 if (SWIG_arg_fail(1)) SWIG_fail;
44653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44654 if (SWIG_arg_fail(2)) SWIG_fail;
44655 {
44656 PyThreadState* __tstate = wxPyBeginAllowThreads();
44657 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44658
44659 wxPyEndAllowThreads(__tstate);
44660 if (PyErr_Occurred()) SWIG_fail;
44661 }
44662 {
44663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44664 }
44665 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44666 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44667 return resultobj;
44668 fail:
44669 return NULL;
44670 }
44671
44672
44673 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44674 PyObject *resultobj;
44675 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44676 bool result;
44677 PyObject * obj0 = 0 ;
44678 char *kwnames[] = {
44679 (char *) "self", NULL
44680 };
44681
44682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44684 if (SWIG_arg_fail(1)) SWIG_fail;
44685 {
44686 PyThreadState* __tstate = wxPyBeginAllowThreads();
44687 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44688
44689 wxPyEndAllowThreads(__tstate);
44690 if (PyErr_Occurred()) SWIG_fail;
44691 }
44692 {
44693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44694 }
44695 return resultobj;
44696 fail:
44697 return NULL;
44698 }
44699
44700
44701 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44702 PyObject *obj;
44703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44704 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44705 Py_INCREF(obj);
44706 return Py_BuildValue((char *)"");
44707 }
44708 static PyMethodDef SwigMethods[] = {
44709 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44710 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44711 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44714 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44735 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44748 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44763 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44816 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44844 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44863 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44865 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44873 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44874 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44886 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44898 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44902 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44908 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44918 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44928 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44932 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45007 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45009 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45011 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45013 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45015 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45017 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45019 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45021 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45023 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45025 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45027 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45029 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45031 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45045 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45063 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45066 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45069 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45081 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45086 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45092 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45098 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45161 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45168 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45204 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45214 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45220 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45222 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45224 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45227 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45231 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45234 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45237 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45239 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45244 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45252 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45256 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45259 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45261 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45265 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45282 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45284 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45287 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45289 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45293 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45297 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45308 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45311 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45314 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45318 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45325 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45330 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45335 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45339 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45384 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45404 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45411 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45415 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45425 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45595 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45635 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45649 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45652 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45707 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45734 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45778 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45786 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45805 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45806 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45843 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45873 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45876 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45880 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45883 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45893 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45905 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45917 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45927 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45937 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45951 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45958 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45959 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45960 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45961 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45962 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45967 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45994 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46006 { NULL, NULL, 0, NULL }
46007 };
46008
46009
46010 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46011
46012 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46013 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46014 }
46015 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46016 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46017 }
46018 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46019 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46020 }
46021 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46022 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46023 }
46024 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46025 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46026 }
46027 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46028 return (void *)((wxSizer *) ((wxGridSizer *) x));
46029 }
46030 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46031 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46032 }
46033 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46034 return (void *)((wxSizer *) ((wxPySizer *) x));
46035 }
46036 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46037 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46038 }
46039 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46040 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46041 }
46042 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46043 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46044 }
46045 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46046 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46047 }
46048 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46049 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46050 }
46051 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46052 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46053 }
46054 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46055 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46056 }
46057 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46058 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46059 }
46060 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46061 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46062 }
46063 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46064 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46065 }
46066 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46067 return (void *)((wxEvent *) ((wxPyEvent *) x));
46068 }
46069 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46070 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46071 }
46072 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46073 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46074 }
46075 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46076 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46077 }
46078 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46079 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46080 }
46081 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46082 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46083 }
46084 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46085 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46086 }
46087 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46088 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46089 }
46090 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46091 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46092 }
46093 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46094 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46095 }
46096 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46097 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46098 }
46099 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46100 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46101 }
46102 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46103 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46104 }
46105 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46106 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46107 }
46108 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46109 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46110 }
46111 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46112 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46113 }
46114 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46115 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46116 }
46117 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46118 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46119 }
46120 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46121 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46122 }
46123 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46124 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46125 }
46126 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46128 }
46129 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46130 return (void *)((wxEvent *) ((wxShowEvent *) x));
46131 }
46132 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46133 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46134 }
46135 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46136 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46137 }
46138 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46139 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46140 }
46141 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46142 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46143 }
46144 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46145 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46146 }
46147 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46148 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46149 }
46150 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46151 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46152 }
46153 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46154 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46155 }
46156 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46157 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46158 }
46159 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46160 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46161 }
46162 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46163 return (void *)((wxControl *) ((wxControlWithItems *) x));
46164 }
46165 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46166 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46167 }
46168 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46169 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46170 }
46171 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46172 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46173 }
46174 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46175 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46176 }
46177 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46178 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46179 }
46180 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46181 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46182 }
46183 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46184 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46185 }
46186 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46187 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46188 }
46189 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46190 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46191 }
46192 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46193 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46194 }
46195 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46196 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46197 }
46198 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46199 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46200 }
46201 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46202 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46203 }
46204 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46205 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46206 }
46207 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46208 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46209 }
46210 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46211 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46212 }
46213 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46214 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46215 }
46216 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46217 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46218 }
46219 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46220 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46221 }
46222 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46223 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46224 }
46225 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46226 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46227 }
46228 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46229 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46230 }
46231 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46232 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46233 }
46234 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46235 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46236 }
46237 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46238 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46239 }
46240 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46241 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46242 }
46243 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46244 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46245 }
46246 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46247 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46248 }
46249 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46250 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46251 }
46252 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46253 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46254 }
46255 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46256 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46257 }
46258 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46259 return (void *)((wxObject *) ((wxSizerItem *) x));
46260 }
46261 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46262 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46263 }
46264 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46265 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46266 }
46267 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46268 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46269 }
46270 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46271 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46272 }
46273 static void *_p_wxSizerTo_p_wxObject(void *x) {
46274 return (void *)((wxObject *) ((wxSizer *) x));
46275 }
46276 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46277 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46278 }
46279 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46280 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46281 }
46282 static void *_p_wxEventTo_p_wxObject(void *x) {
46283 return (void *)((wxObject *) ((wxEvent *) x));
46284 }
46285 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46286 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46287 }
46288 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46289 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46290 }
46291 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46292 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46293 }
46294 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46295 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46296 }
46297 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46298 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46299 }
46300 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46301 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46302 }
46303 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46304 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46305 }
46306 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46307 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46308 }
46309 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46310 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46311 }
46312 static void *_p_wxControlTo_p_wxObject(void *x) {
46313 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46314 }
46315 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46316 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46317 }
46318 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46319 return (void *)((wxObject *) ((wxFSFile *) x));
46320 }
46321 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46322 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46323 }
46324 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46325 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46326 }
46327 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46329 }
46330 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46331 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46332 }
46333 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46334 return (void *)((wxObject *) ((wxMenuItem *) x));
46335 }
46336 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46337 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46338 }
46339 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46340 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46341 }
46342 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46343 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46344 }
46345 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46346 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46347 }
46348 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46349 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46350 }
46351 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46352 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46353 }
46354 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46355 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46356 }
46357 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46358 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46359 }
46360 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46361 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46362 }
46363 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46364 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46365 }
46366 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46367 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46368 }
46369 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46370 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46371 }
46372 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46373 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46374 }
46375 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46376 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46377 }
46378 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46379 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46380 }
46381 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46382 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46383 }
46384 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46385 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46386 }
46387 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46388 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46389 }
46390 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46391 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46392 }
46393 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46394 return (void *)((wxObject *) ((wxImageHandler *) x));
46395 }
46396 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46397 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46398 }
46399 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46400 return (void *)((wxObject *) ((wxEvtHandler *) x));
46401 }
46402 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46403 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46404 }
46405 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46406 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46407 }
46408 static void *_p_wxImageTo_p_wxObject(void *x) {
46409 return (void *)((wxObject *) ((wxImage *) x));
46410 }
46411 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46412 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46413 }
46414 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46415 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46416 }
46417 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46418 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46419 }
46420 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46421 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46422 }
46423 static void *_p_wxWindowTo_p_wxObject(void *x) {
46424 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46425 }
46426 static void *_p_wxMenuTo_p_wxObject(void *x) {
46427 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46428 }
46429 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46430 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46431 }
46432 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46433 return (void *)((wxObject *) ((wxFileSystem *) x));
46434 }
46435 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46436 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46437 }
46438 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46439 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46440 }
46441 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46442 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46443 }
46444 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46445 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46446 }
46447 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46448 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46449 }
46450 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46451 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46452 }
46453 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46454 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46455 }
46456 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46457 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46458 }
46459 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46460 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46461 }
46462 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46463 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46464 }
46465 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46467 }
46468 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46469 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46470 }
46471 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46472 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46473 }
46474 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46475 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46476 }
46477 static void *_p_wxControlTo_p_wxWindow(void *x) {
46478 return (void *)((wxWindow *) ((wxControl *) x));
46479 }
46480 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46481 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46482 }
46483 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46484 return (void *)((wxWindow *) ((wxMenuBar *) x));
46485 }
46486 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46487 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46488 }
46489 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46490 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46491 }
46492 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46493 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46494 }
46495 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46496 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46497 }
46498 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46499 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46500 }
46501 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46502 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46503 }
46504 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46505 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46506 }
46507 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46508 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46509 }
46510 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46511 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46512 }
46513 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46514 return (void *)((wxValidator *) ((wxPyValidator *) x));
46515 }
46516 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}};
46517 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}};
46518 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}};
46519 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}};
46520 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}};
46521 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}};
46522 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}};
46523 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}};
46524 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}};
46525 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}};
46526 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}};
46527 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}};
46528 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}};
46529 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}};
46530 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}};
46531 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}};
46532 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}};
46533 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}};
46534 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}};
46535 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}};
46536 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}};
46537 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}};
46538 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}};
46539 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}};
46540 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}};
46541 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}};
46542 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}};
46543 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}};
46544 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}};
46545 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}};
46546 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}};
46547 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}};
46548 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}};
46549 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}};
46550 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}};
46551 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}};
46552 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}};
46553 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}};
46554 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}};
46555 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}};
46556 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}};
46557 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}};
46558 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}};
46559 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}};
46560 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}};
46561 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}};
46562 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}};
46563 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}};
46564 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}};
46565 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}};
46566 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}};
46567 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}};
46568 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}};
46569 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}};
46570 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}};
46571 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}};
46572 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}};
46573 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}};
46574 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}};
46575 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}};
46576 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}};
46577 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}};
46578 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}};
46579 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}};
46580 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}};
46581 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}};
46582 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}};
46583 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}};
46584 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}};
46585 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}};
46586 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}};
46587 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}};
46588 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}};
46589 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}};
46590 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}};
46591 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}};
46592 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}};
46593 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}};
46594 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}};
46595 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}};
46596 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}};
46597 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}};
46598 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}};
46599 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}};
46600 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}};
46601 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}};
46602 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}};
46603 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}};
46604 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}};
46605 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}};
46606 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}};
46607 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}};
46608 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}};
46609 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}};
46610 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}};
46611 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}};
46612 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}};
46613 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}};
46614 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}};
46615 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}};
46616 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}};
46617 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}};
46618 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}};
46619 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}};
46620 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}};
46621 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}};
46622 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}};
46623 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}};
46624 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}};
46625 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}};
46626 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}};
46627 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46628 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}};
46629 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}};
46630 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}};
46631 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}};
46632 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}};
46633 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}};
46634 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}};
46635 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}};
46636 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}};
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643
46644 static swig_type_info *swig_types_initial[] = {
46645 _swigt__p_wxLayoutConstraints,
46646 _swigt__p_wxRealPoint,
46647 _swigt__p_wxSizerItem,
46648 _swigt__p_wxGBSizerItem,
46649 _swigt__p_wxScrollEvent,
46650 _swigt__p_wxEventLoop,
46651 _swigt__p_wxIndividualLayoutConstraint,
46652 _swigt__p_wxSizer,
46653 _swigt__p_wxBoxSizer,
46654 _swigt__p_wxStaticBoxSizer,
46655 _swigt__p_wxGridBagSizer,
46656 _swigt__p_wxAcceleratorEntry,
46657 _swigt__p_wxUpdateUIEvent,
46658 _swigt__p_wxEvent,
46659 _swigt__p_wxMenu,
46660 _swigt__p_wxGridSizer,
46661 _swigt__p_wxFlexGridSizer,
46662 _swigt__p_wxInitDialogEvent,
46663 _swigt__p_wxItemContainer,
46664 _swigt__p_wxNcPaintEvent,
46665 _swigt__p_wxPaintEvent,
46666 _swigt__p_wxSysColourChangedEvent,
46667 _swigt__p_wxMouseCaptureChangedEvent,
46668 _swigt__p_wxDisplayChangedEvent,
46669 _swigt__p_wxPaletteChangedEvent,
46670 _swigt__p_wxControl,
46671 _swigt__p_wxFont,
46672 _swigt__p_wxMenuBarBase,
46673 _swigt__p_wxSetCursorEvent,
46674 _swigt__p_wxFSFile,
46675 _swigt__p_wxCaret,
46676 _swigt__ptrdiff_t,
46677 _swigt__std__ptrdiff_t,
46678 _swigt__p_wxRegion,
46679 _swigt__p_wxPoint2D,
46680 _swigt__p_int,
46681 _swigt__p_wxSize,
46682 _swigt__p_wxDC,
46683 _swigt__p_wxPySizer,
46684 _swigt__p_wxVisualAttributes,
46685 _swigt__p_wxNotifyEvent,
46686 _swigt__p_wxPyEvent,
46687 _swigt__p_wxPropagationDisabler,
46688 _swigt__p_form_ops_t,
46689 _swigt__p_wxAppTraits,
46690 _swigt__p_wxArrayString,
46691 _swigt__p_wxShowEvent,
46692 _swigt__p_wxToolTip,
46693 _swigt__p_wxMoveEvent,
46694 _swigt__p_wxSizeEvent,
46695 _swigt__p_wxActivateEvent,
46696 _swigt__p_wxIconizeEvent,
46697 _swigt__p_wxMaximizeEvent,
46698 _swigt__p_wxQueryNewPaletteEvent,
46699 _swigt__p_wxWindowCreateEvent,
46700 _swigt__p_wxIdleEvent,
46701 _swigt__p_wxDateEvent,
46702 _swigt__p_wxMenuItem,
46703 _swigt__p_wxStaticBox,
46704 _swigt__p_long,
46705 _swigt__p_wxDuplexMode,
46706 _swigt__p_wxTIFFHandler,
46707 _swigt__p_wxXPMHandler,
46708 _swigt__p_wxPNMHandler,
46709 _swigt__p_wxJPEGHandler,
46710 _swigt__p_wxPCXHandler,
46711 _swigt__p_wxGIFHandler,
46712 _swigt__p_wxPNGHandler,
46713 _swigt__p_wxANIHandler,
46714 _swigt__p_wxMemoryFSHandler,
46715 _swigt__p_wxZipFSHandler,
46716 _swigt__p_wxInternetFSHandler,
46717 _swigt__p_wxPyFileSystemHandler,
46718 _swigt__p_wxEvtHandler,
46719 _swigt__p_wxCURHandler,
46720 _swigt__p_wxICOHandler,
46721 _swigt__p_wxBMPHandler,
46722 _swigt__p_wxImageHandler,
46723 _swigt__p_wxFileSystemHandler,
46724 _swigt__p_wxRect,
46725 _swigt__p_wxButton,
46726 _swigt__p_wxGBSpan,
46727 _swigt__p_wxPropagateOnce,
46728 _swigt__p_wxAcceleratorTable,
46729 _swigt__p_wxStdDialogButtonSizer,
46730 _swigt__p_char,
46731 _swigt__p_wxGBPosition,
46732 _swigt__p_wxImage,
46733 _swigt__p_wxFrame,
46734 _swigt__p_wxScrollWinEvent,
46735 _swigt__p_wxPaperSize,
46736 _swigt__p_wxImageHistogram,
46737 _swigt__p_wxPoint,
46738 _swigt__p_wxCursor,
46739 _swigt__p_wxObject,
46740 _swigt__p_wxInputStream,
46741 _swigt__p_wxOutputStream,
46742 _swigt__p_wxPyInputStream,
46743 _swigt__p_wxDateTime,
46744 _swigt__p_wxKeyEvent,
46745 _swigt__p_wxNavigationKeyEvent,
46746 _swigt__p_wxWindowDestroyEvent,
46747 _swigt__p_unsigned_long,
46748 _swigt__p_wxWindow,
46749 _swigt__p_wxMenuBar,
46750 _swigt__p_wxFileSystem,
46751 _swigt__p_wxBitmap,
46752 _swigt__unsigned_int,
46753 _swigt__p_unsigned_int,
46754 _swigt__p_wxMenuEvent,
46755 _swigt__p_wxContextMenuEvent,
46756 _swigt__p_unsigned_char,
46757 _swigt__p_wxEraseEvent,
46758 _swigt__p_wxMouseEvent,
46759 _swigt__p_wxCloseEvent,
46760 _swigt__p_wxPyApp,
46761 _swigt__p_wxCommandEvent,
46762 _swigt__p_wxPyCommandEvent,
46763 _swigt__p_wxPyDropTarget,
46764 _swigt__p_wxQuantize,
46765 _swigt__p_wxChildFocusEvent,
46766 _swigt__p_wxFocusEvent,
46767 _swigt__p_wxDropFilesEvent,
46768 _swigt__p_wxControlWithItems,
46769 _swigt__p_wxColour,
46770 _swigt__p_wxValidator,
46771 _swigt__p_wxPyValidator,
46772 0
46773 };
46774
46775
46776 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46777
46778 static swig_const_info swig_const_table[] = {
46779 {0, 0, 0, 0.0, 0, 0}};
46780
46781 #ifdef __cplusplus
46782 }
46783 #endif
46784
46785
46786 #ifdef __cplusplus
46787 extern "C" {
46788 #endif
46789
46790 /* Python-specific SWIG API */
46791 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46792 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46793 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46794
46795 /* -----------------------------------------------------------------------------
46796 * global variable support code.
46797 * ----------------------------------------------------------------------------- */
46798
46799 typedef struct swig_globalvar {
46800 char *name; /* Name of global variable */
46801 PyObject *(*get_attr)(); /* Return the current value */
46802 int (*set_attr)(PyObject *); /* Set the value */
46803 struct swig_globalvar *next;
46804 } swig_globalvar;
46805
46806 typedef struct swig_varlinkobject {
46807 PyObject_HEAD
46808 swig_globalvar *vars;
46809 } swig_varlinkobject;
46810
46811 static PyObject *
46812 swig_varlink_repr(swig_varlinkobject *v) {
46813 v = v;
46814 return PyString_FromString("<Swig global variables>");
46815 }
46816
46817 static int
46818 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46819 swig_globalvar *var;
46820 flags = flags;
46821 fprintf(fp,"Swig global variables { ");
46822 for (var = v->vars; var; var=var->next) {
46823 fprintf(fp,"%s", var->name);
46824 if (var->next) fprintf(fp,", ");
46825 }
46826 fprintf(fp," }\n");
46827 return 0;
46828 }
46829
46830 static PyObject *
46831 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46832 swig_globalvar *var = v->vars;
46833 while (var) {
46834 if (strcmp(var->name,n) == 0) {
46835 return (*var->get_attr)();
46836 }
46837 var = var->next;
46838 }
46839 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46840 return NULL;
46841 }
46842
46843 static int
46844 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46845 swig_globalvar *var = v->vars;
46846 while (var) {
46847 if (strcmp(var->name,n) == 0) {
46848 return (*var->set_attr)(p);
46849 }
46850 var = var->next;
46851 }
46852 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46853 return 1;
46854 }
46855
46856 static PyTypeObject varlinktype = {
46857 PyObject_HEAD_INIT(0)
46858 0, /* Number of items in variable part (ob_size) */
46859 (char *)"swigvarlink", /* Type name (tp_name) */
46860 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46861 0, /* Itemsize (tp_itemsize) */
46862 0, /* Deallocator (tp_dealloc) */
46863 (printfunc) swig_varlink_print, /* Print (tp_print) */
46864 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46865 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46866 0, /* tp_compare */
46867 (reprfunc) swig_varlink_repr, /* tp_repr */
46868 0, /* tp_as_number */
46869 0, /* tp_as_sequence */
46870 0, /* tp_as_mapping */
46871 0, /* tp_hash */
46872 0, /* tp_call */
46873 0, /* tp_str */
46874 0, /* tp_getattro */
46875 0, /* tp_setattro */
46876 0, /* tp_as_buffer */
46877 0, /* tp_flags */
46878 0, /* tp_doc */
46879 #if PY_VERSION_HEX >= 0x02000000
46880 0, /* tp_traverse */
46881 0, /* tp_clear */
46882 #endif
46883 #if PY_VERSION_HEX >= 0x02010000
46884 0, /* tp_richcompare */
46885 0, /* tp_weaklistoffset */
46886 #endif
46887 #if PY_VERSION_HEX >= 0x02020000
46888 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46889 #endif
46890 #if PY_VERSION_HEX >= 0x02030000
46891 0, /* tp_del */
46892 #endif
46893 #ifdef COUNT_ALLOCS
46894 0,0,0,0 /* tp_alloc -> tp_next */
46895 #endif
46896 };
46897
46898 /* Create a variable linking object for use later */
46899 static PyObject *
46900 SWIG_Python_newvarlink(void) {
46901 swig_varlinkobject *result = 0;
46902 result = PyMem_NEW(swig_varlinkobject,1);
46903 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46904 result->ob_type = &varlinktype;
46905 result->vars = 0;
46906 result->ob_refcnt = 0;
46907 Py_XINCREF((PyObject *) result);
46908 return ((PyObject*) result);
46909 }
46910
46911 static void
46912 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46913 swig_varlinkobject *v;
46914 swig_globalvar *gv;
46915 v= (swig_varlinkobject *) p;
46916 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46917 gv->name = (char *) malloc(strlen(name)+1);
46918 strcpy(gv->name,name);
46919 gv->get_attr = get_attr;
46920 gv->set_attr = set_attr;
46921 gv->next = v->vars;
46922 v->vars = gv;
46923 }
46924
46925 /* -----------------------------------------------------------------------------
46926 * constants/methods manipulation
46927 * ----------------------------------------------------------------------------- */
46928
46929 /* Install Constants */
46930 static void
46931 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46932 PyObject *obj = 0;
46933 size_t i;
46934 for (i = 0; constants[i].type; i++) {
46935 switch(constants[i].type) {
46936 case SWIG_PY_INT:
46937 obj = PyInt_FromLong(constants[i].lvalue);
46938 break;
46939 case SWIG_PY_FLOAT:
46940 obj = PyFloat_FromDouble(constants[i].dvalue);
46941 break;
46942 case SWIG_PY_STRING:
46943 if (constants[i].pvalue) {
46944 obj = PyString_FromString((char *) constants[i].pvalue);
46945 } else {
46946 Py_INCREF(Py_None);
46947 obj = Py_None;
46948 }
46949 break;
46950 case SWIG_PY_POINTER:
46951 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46952 break;
46953 case SWIG_PY_BINARY:
46954 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46955 break;
46956 default:
46957 obj = 0;
46958 break;
46959 }
46960 if (obj) {
46961 PyDict_SetItemString(d,constants[i].name,obj);
46962 Py_DECREF(obj);
46963 }
46964 }
46965 }
46966
46967 /* -----------------------------------------------------------------------------*/
46968 /* Fix SwigMethods to carry the callback ptrs when needed */
46969 /* -----------------------------------------------------------------------------*/
46970
46971 static void
46972 SWIG_Python_FixMethods(PyMethodDef *methods,
46973 swig_const_info *const_table,
46974 swig_type_info **types,
46975 swig_type_info **types_initial) {
46976 size_t i;
46977 for (i = 0; methods[i].ml_name; ++i) {
46978 char *c = methods[i].ml_doc;
46979 if (c && (c = strstr(c, "swig_ptr: "))) {
46980 int j;
46981 swig_const_info *ci = 0;
46982 char *name = c + 10;
46983 for (j = 0; const_table[j].type; j++) {
46984 if (strncmp(const_table[j].name, name,
46985 strlen(const_table[j].name)) == 0) {
46986 ci = &(const_table[j]);
46987 break;
46988 }
46989 }
46990 if (ci) {
46991 size_t shift = (ci->ptype) - types;
46992 swig_type_info *ty = types_initial[shift];
46993 size_t ldoc = (c - methods[i].ml_doc);
46994 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46995 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46996 char *buff = ndoc;
46997 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46998 strncpy(buff, methods[i].ml_doc, ldoc);
46999 buff += ldoc;
47000 strncpy(buff, "swig_ptr: ", 10);
47001 buff += 10;
47002 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47003 methods[i].ml_doc = ndoc;
47004 }
47005 }
47006 }
47007 }
47008
47009 /* -----------------------------------------------------------------------------*
47010 * Initialize type list
47011 * -----------------------------------------------------------------------------*/
47012
47013 #if PY_MAJOR_VERSION < 2
47014 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47015 is copied out of Python/modsupport.c in python version 2.3.4 */
47016 static int
47017 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47018 {
47019 PyObject *dict;
47020 if (!PyModule_Check(m)) {
47021 PyErr_SetString(PyExc_TypeError,
47022 "PyModule_AddObject() needs module as first arg");
47023 return -1;
47024 }
47025 if (!o) {
47026 PyErr_SetString(PyExc_TypeError,
47027 "PyModule_AddObject() needs non-NULL value");
47028 return -1;
47029 }
47030
47031 dict = PyModule_GetDict(m);
47032 if (dict == NULL) {
47033 /* Internal error -- modules must have a dict! */
47034 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47035 PyModule_GetName(m));
47036 return -1;
47037 }
47038 if (PyDict_SetItemString(dict, name, o))
47039 return -1;
47040 Py_DECREF(o);
47041 return 0;
47042 }
47043 #endif
47044
47045 static swig_type_info **
47046 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47047 static PyMethodDef swig_empty_runtime_method_table[] = {
47048 {
47049 NULL, NULL, 0, NULL
47050 }
47051 };/* Sentinel */
47052
47053 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47054 swig_empty_runtime_method_table);
47055 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47056 if (pointer && module) {
47057 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47058 }
47059 return type_list_handle;
47060 }
47061
47062 static swig_type_info **
47063 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47064 swig_type_info **type_pointer;
47065
47066 /* first check if module already created */
47067 type_pointer = SWIG_Python_GetTypeListHandle();
47068 if (type_pointer) {
47069 return type_pointer;
47070 } else {
47071 /* create a new module and variable */
47072 return SWIG_Python_SetTypeListHandle(type_list_handle);
47073 }
47074 }
47075
47076 #ifdef __cplusplus
47077 }
47078 #endif
47079
47080 /* -----------------------------------------------------------------------------*
47081 * Partial Init method
47082 * -----------------------------------------------------------------------------*/
47083
47084 #ifdef SWIG_LINK_RUNTIME
47085 #ifdef __cplusplus
47086 extern "C"
47087 #endif
47088 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47089 #endif
47090
47091 #ifdef __cplusplus
47092 extern "C"
47093 #endif
47094 SWIGEXPORT(void) SWIG_init(void) {
47095 static PyObject *SWIG_globals = 0;
47096 static int typeinit = 0;
47097 PyObject *m, *d;
47098 int i;
47099 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47100
47101 /* Fix SwigMethods to carry the callback ptrs when needed */
47102 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47103
47104 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47105 d = PyModule_GetDict(m);
47106
47107 if (!typeinit) {
47108 #ifdef SWIG_LINK_RUNTIME
47109 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47110 #else
47111 # ifndef SWIG_STATIC_RUNTIME
47112 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47113 # endif
47114 #endif
47115 for (i = 0; swig_types_initial[i]; i++) {
47116 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47117 }
47118 typeinit = 1;
47119 }
47120 SWIG_InstallConstants(d,swig_const_table);
47121
47122
47123 #ifndef wxPyUSE_EXPORT
47124 // Make our API structure a CObject so other modules can import it
47125 // from this module.
47126 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47127 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47128 Py_XDECREF(cobj);
47129 #endif
47130
47131 {
47132 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47133 }
47134 {
47135 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47136 }
47137 {
47138 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47139 }
47140 {
47141 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47142 }
47143 {
47144 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47145 }
47146 {
47147 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47148 }
47149 {
47150 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47151 }
47152 {
47153 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48735 }
48736 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48737 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48738 {
48739 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48890 }
48891 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48892 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48893 {
48894 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48901 }
48902
48903 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48904
48905
48906 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48907
48908 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48909 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
48910 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48911 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48912 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48913 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48914 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
48915 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
48916 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48917 {
48918 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48922 }
48923 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
48924 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
48925 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
48926 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
48927 {
48928 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48965 }
48966 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48967 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48968 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48969 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48970 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48971 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48972 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48973 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48974 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48975 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48976 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48977 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48978 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48979 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48980 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48981 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48982 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48983 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48984 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48985 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48986 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48987 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48988 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48989 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48990 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48991 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48992 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48993 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48994 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48995 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48996 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48997 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48998 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48999 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49000 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49001 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49002 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49003 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49004 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49005 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49006 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49007 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49008 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49009 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49010 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49011 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49012 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49013 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49014 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49015 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49016 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49017 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49018 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49019 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49020 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49021 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49022 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49023 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49024 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49025 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49026 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49027 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49028 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49029 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49030 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49031 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49032 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49033 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49034 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49035 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49036 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49037 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49038 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49039 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49040 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49041 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49042 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49043 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49044 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49045 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49046 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49047 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49048 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49049 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49050 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49051 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49052 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49053 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49054 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49055 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49056 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49057 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49058 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49059 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49060 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49061 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49062 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49063 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49064 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49065 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49066 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49067 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49068 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49069 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49070 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49071 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49072 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49073 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49074 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49075 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49076 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49077 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49078 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49079 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49080 {
49081 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49118 }
49119 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49120 {
49121 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49137 }
49138 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49139 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49140 {
49141 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49154 }
49155 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49156 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49157 {
49158 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49165 }
49166 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49167 {
49168 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49223 }
49224
49225 // Initialize threading, some globals and such
49226 __wxPyPreStart(d);
49227
49228
49229 // Although these are defined in __version__ they need to be here too so
49230 // that an assert can be done to ensure that the wxPython and the wxWindows
49231 // versions match.
49232 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49233 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49234 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49235
49236 }
49237
wxWidgets (Impactor)