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


461ff8bddd63ebffc7b782ca2a4b47e964cf83d6
[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_buffer swig_types[14]
1356 #define SWIGTYPE_p_wxMenu swig_types[15]
1357 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1359 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1360 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1361 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1363 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxFont swig_types[27]
1369 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1370 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1371 #define SWIGTYPE_p_wxFSFile swig_types[30]
1372 #define SWIGTYPE_p_wxCaret swig_types[31]
1373 #define SWIGTYPE_ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1375 #define SWIGTYPE_p_wxRegion swig_types[34]
1376 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1377 #define SWIGTYPE_p_int swig_types[36]
1378 #define SWIGTYPE_p_wxSize swig_types[37]
1379 #define SWIGTYPE_p_wxDC swig_types[38]
1380 #define SWIGTYPE_p_wxPySizer swig_types[39]
1381 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1382 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1384 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1387 #define SWIGTYPE_p_wxArrayString swig_types[46]
1388 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1389 #define SWIGTYPE_p_wxToolTip swig_types[48]
1390 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1391 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1392 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1393 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1395 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1396 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1397 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1398 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1399 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1400 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1401 #define SWIGTYPE_p_long swig_types[60]
1402 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1403 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1404 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1406 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1408 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1409 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1410 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1411 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1414 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1415 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1416 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1417 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1418 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1419 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1420 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1421 #define SWIGTYPE_p_wxRect swig_types[80]
1422 #define SWIGTYPE_p_wxButton swig_types[81]
1423 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1424 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1425 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1426 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1427 #define SWIGTYPE_p_char swig_types[86]
1428 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1429 #define SWIGTYPE_p_wxImage swig_types[88]
1430 #define SWIGTYPE_p_wxFrame swig_types[89]
1431 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1433 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1434 #define SWIGTYPE_p_wxPoint swig_types[93]
1435 #define SWIGTYPE_p_wxCursor swig_types[94]
1436 #define SWIGTYPE_p_wxObject swig_types[95]
1437 #define SWIGTYPE_p_wxInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1439 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1440 #define SWIGTYPE_p_wxDateTime swig_types[99]
1441 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1443 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1444 #define SWIGTYPE_p_unsigned_long swig_types[103]
1445 #define SWIGTYPE_p_wxWindow swig_types[104]
1446 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1447 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1448 #define SWIGTYPE_p_wxBitmap swig_types[107]
1449 #define SWIGTYPE_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_unsigned_int swig_types[109]
1451 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1453 #define SWIGTYPE_p_unsigned_char swig_types[112]
1454 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyApp swig_types[116]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1460 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1461 #define SWIGTYPE_p_wxQuantize swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1466 #define SWIGTYPE_p_wxColour swig_types[125]
1467 #define SWIGTYPE_p_wxValidator swig_types[126]
1468 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1469 static swig_type_info *swig_types[129];
1470
1471 /* -------- TYPES TABLE (END) -------- */
1472
1473
1474 /*-----------------------------------------------
1475 @(target):= _core_.so
1476 ------------------------------------------------*/
1477 #define SWIG_init init_core_
1478
1479 #define SWIG_name "_core_"
1480
1481 #include "wx/wxPython/wxPython_int.h"
1482 #include "wx/wxPython/pyclasses.h"
1483
1484
1485 #ifndef wxPyUSE_EXPORT
1486 // Helper functions for dealing with SWIG objects and such. These are
1487 // located here so they know about the SWIG types and functions declared
1488 // in the wrapper code.
1489
1490 #include <wx/hashmap.h>
1491 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1492
1493
1494 // Maintains a hashmap of className to swig_type_info pointers. Given the
1495 // name of a class either looks up the type info in the cache, or scans the
1496 // SWIG tables for it.
1497 extern PyObject* wxPyPtrTypeMap;
1498 static
1499 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1500
1501 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1502
1503 if (typeInfoCache == NULL)
1504 typeInfoCache = new wxPyTypeInfoHashMap;
1505
1506 wxString name(className);
1507 swig_type_info* swigType = (*typeInfoCache)[name];
1508
1509 if (! swigType) {
1510 // it wasn't in the cache, so look it up from SWIG
1511 name.Append(wxT(" *"));
1512 swigType = SWIG_TypeQuery(name.mb_str());
1513
1514 // if it still wasn't found, try looking for a mapped name
1515 if (!swigType) {
1516 PyObject* item;
1517 name = className;
1518
1519 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1520 (char*)(const char*)name.mbc_str())) != NULL) {
1521 name = wxString(PyString_AsString(item), *wxConvCurrent);
1522 name.Append(wxT(" *"));
1523 swigType = SWIG_TypeQuery(name.mb_str());
1524 }
1525 }
1526 if (swigType) {
1527 // and add it to the map if found
1528 (*typeInfoCache)[className] = swigType;
1529 }
1530 }
1531 return swigType;
1532 }
1533
1534
1535 // Check if a class name is a type known to SWIG
1536 bool wxPyCheckSwigType(const wxChar* className) {
1537
1538 swig_type_info* swigType = wxPyFindSwigType(className);
1539 return swigType != NULL;
1540 }
1541
1542
1543 // Given a pointer to a C++ object and a class name, construct a Python proxy
1544 // object for it.
1545 PyObject* wxPyConstructObject(void* ptr,
1546 const wxChar* className,
1547 int setThisOwn) {
1548
1549 swig_type_info* swigType = wxPyFindSwigType(className);
1550 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1551
1552 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1553 }
1554
1555
1556 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1557 // Ensures that the proxy object is of the specified (or derived) type. If
1558 // not able to perform the conversion then a Python exception is set and the
1559 // error should be handled properly in the caller. Returns True on success.
1560 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1561 const wxChar* className) {
1562
1563 swig_type_info* swigType = wxPyFindSwigType(className);
1564 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1565
1566 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1567 }
1568
1569
1570 // Make a SWIGified pointer object suitable for a .this attribute
1571 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1572
1573 PyObject* robj = NULL;
1574
1575 swig_type_info* swigType = wxPyFindSwigType(className);
1576 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1577
1578 #ifdef SWIG_COBJECT_TYPES
1579 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1580 #else
1581 {
1582 char result[1024];
1583 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1584 PyString_FromString(result) : 0;
1585 }
1586 #endif
1587
1588 return robj;
1589 }
1590
1591
1592
1593
1594 // Export a C API in a struct. Other modules will be able to load this from
1595 // the wx._core_ module and will then have safe access to these functions,
1596 // even if they are located in another shared library.
1597 static wxPyCoreAPI API = {
1598
1599 wxPyCheckSwigType,
1600 wxPyConstructObject,
1601 wxPyConvertSwigPtr,
1602 wxPyMakeSwigPtr,
1603
1604 wxPyBeginAllowThreads,
1605 wxPyEndAllowThreads,
1606 wxPyBeginBlockThreads,
1607 wxPyEndBlockThreads,
1608
1609 wxPy_ConvertList,
1610
1611 wxString_in_helper,
1612 Py2wxString,
1613 wx2PyString,
1614
1615 byte_LIST_helper,
1616 int_LIST_helper,
1617 long_LIST_helper,
1618 string_LIST_helper,
1619 wxPoint_LIST_helper,
1620 wxBitmap_LIST_helper,
1621 wxString_LIST_helper,
1622 wxAcceleratorEntry_LIST_helper,
1623
1624 wxSize_helper,
1625 wxPoint_helper,
1626 wxRealPoint_helper,
1627 wxRect_helper,
1628 wxColour_helper,
1629 wxPoint2D_helper,
1630
1631 wxPySimple_typecheck,
1632 wxColour_typecheck,
1633
1634 wxPyCBH_setCallbackInfo,
1635 wxPyCBH_findCallback,
1636 wxPyCBH_callCallback,
1637 wxPyCBH_callCallbackObj,
1638 wxPyCBH_delete,
1639
1640 wxPyMake_wxObject,
1641 wxPyMake_wxSizer,
1642 wxPyPtrTypeMap_Add,
1643 wxPy2int_seq_helper,
1644 wxPy4int_seq_helper,
1645 wxArrayString2PyList_helper,
1646 wxArrayInt2PyList_helper,
1647
1648 wxPyClientData_dtor,
1649 wxPyUserData_dtor,
1650 wxPyOORClientData_dtor,
1651
1652 wxPyCBInputStream_create,
1653 wxPyCBInputStream_copy,
1654
1655 wxPyInstance_Check,
1656 wxPySwigInstance_Check,
1657
1658 wxPyCheckForApp
1659
1660 };
1661
1662 #endif
1663
1664
1665 #if !WXWIN_COMPATIBILITY_2_4
1666 #define wxHIDE_READONLY 0
1667 #endif
1668
1669
1670 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1671 #define SWIG_From_int PyInt_FromLong
1672 /*@@*/
1673
1674
1675 #if ! wxUSE_HOTKEY
1676 enum wxHotkeyModifier
1677 {
1678 wxMOD_NONE = 0,
1679 wxMOD_ALT = 1,
1680 wxMOD_CONTROL = 2,
1681 wxMOD_SHIFT = 4,
1682 wxMOD_WIN = 8
1683 };
1684 #define wxEVT_HOTKEY 9999
1685 #endif
1686
1687 static const wxString wxPyEmptyString(wxEmptyString);
1688 static wxString wxObject_GetClassName(wxObject *self){
1689 return self->GetClassInfo()->GetClassName();
1690 }
1691 static void wxObject_Destroy(wxObject *self){
1692 delete self;
1693 }
1694
1695 #ifndef __WXMAC__
1696 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1697 #endif
1698
1699
1700 #include <limits.h>
1701
1702
1703 SWIGINTERN int
1704 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1705 const char *errmsg)
1706 {
1707 if (value < min_value) {
1708 if (errmsg) {
1709 PyErr_Format(PyExc_OverflowError,
1710 "value %ld is less than '%s' minimum %ld",
1711 value, errmsg, min_value);
1712 }
1713 return 0;
1714 } else if (value > max_value) {
1715 if (errmsg) {
1716 PyErr_Format(PyExc_OverflowError,
1717 "value %ld is greater than '%s' maximum %ld",
1718 value, errmsg, max_value);
1719 }
1720 return 0;
1721 }
1722 return 1;
1723 }
1724
1725
1726 SWIGINTERN int
1727 SWIG_AsVal_long(PyObject* obj, long* val)
1728 {
1729 if (PyNumber_Check(obj)) {
1730 if (val) *val = PyInt_AsLong(obj);
1731 return 1;
1732 }
1733 else {
1734 SWIG_type_error("number", obj);
1735 }
1736 return 0;
1737 }
1738
1739
1740 #if INT_MAX != LONG_MAX
1741 SWIGINTERN int
1742 SWIG_AsVal_int(PyObject *obj, int *val)
1743 {
1744 const char* errmsg = val ? "int" : (char*)0;
1745 long v;
1746 if (SWIG_AsVal_long(obj, &v)) {
1747 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1748 if (val) *val = (int)(v);
1749 return 1;
1750 } else {
1751 return 0;
1752 }
1753 } else {
1754 PyErr_Clear();
1755 }
1756 if (val) {
1757 SWIG_type_error(errmsg, obj);
1758 }
1759 return 0;
1760 }
1761 #else
1762 SWIGINTERNSHORT int
1763 SWIG_AsVal_int(PyObject *obj, int *val)
1764 {
1765 return SWIG_AsVal_long(obj,(long*)val);
1766 }
1767 #endif
1768
1769
1770 SWIGINTERNSHORT int
1771 SWIG_As_int(PyObject* obj)
1772 {
1773 int v;
1774 if (!SWIG_AsVal_int(obj, &v)) {
1775 /*
1776 this is needed to make valgrind/purify happier.
1777 */
1778 memset((void*)&v, 0, sizeof(int));
1779 }
1780 return v;
1781 }
1782
1783
1784 SWIGINTERNSHORT int
1785 SWIG_Check_int(PyObject* obj)
1786 {
1787 return SWIG_AsVal_int(obj, (int*)0);
1788 }
1789
1790 static PyObject *wxSize_Get(wxSize *self){
1791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1792 PyObject* tup = PyTuple_New(2);
1793 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1794 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1795 wxPyEndBlockThreads(blocked);
1796 return tup;
1797 }
1798
1799 SWIGINTERN int
1800 SWIG_AsVal_double(PyObject *obj, double* val)
1801 {
1802 if (PyNumber_Check(obj)) {
1803 if (val) *val = PyFloat_AsDouble(obj);
1804 return 1;
1805 }
1806 else {
1807 SWIG_type_error("number", obj);
1808 }
1809 return 0;
1810 }
1811
1812
1813 SWIGINTERNSHORT double
1814 SWIG_As_double(PyObject* obj)
1815 {
1816 double v;
1817 if (!SWIG_AsVal_double(obj, &v)) {
1818 /*
1819 this is needed to make valgrind/purify happier.
1820 */
1821 memset((void*)&v, 0, sizeof(double));
1822 }
1823 return v;
1824 }
1825
1826
1827 SWIGINTERNSHORT int
1828 SWIG_Check_double(PyObject* obj)
1829 {
1830 return SWIG_AsVal_double(obj, (double*)0);
1831 }
1832
1833
1834 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1835 #define SWIG_From_double PyFloat_FromDouble
1836 /*@@*/
1837
1838 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1839 self->x = x;
1840 self->y = y;
1841 }
1842 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1844 PyObject* tup = PyTuple_New(2);
1845 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1846 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1847 wxPyEndBlockThreads(blocked);
1848 return tup;
1849 }
1850
1851 SWIGINTERNSHORT long
1852 SWIG_As_long(PyObject* obj)
1853 {
1854 long v;
1855 if (!SWIG_AsVal_long(obj, &v)) {
1856 /*
1857 this is needed to make valgrind/purify happier.
1858 */
1859 memset((void*)&v, 0, sizeof(long));
1860 }
1861 return v;
1862 }
1863
1864
1865 SWIGINTERNSHORT int
1866 SWIG_Check_long(PyObject* obj)
1867 {
1868 return SWIG_AsVal_long(obj, (long*)0);
1869 }
1870
1871 static void wxPoint_Set(wxPoint *self,long x,long y){
1872 self->x = x;
1873 self->y = y;
1874 }
1875 static PyObject *wxPoint_Get(wxPoint *self){
1876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1877 PyObject* tup = PyTuple_New(2);
1878 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1879 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1880 wxPyEndBlockThreads(blocked);
1881 return tup;
1882 }
1883 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1884 self->x = x;
1885 self->y = y;
1886 self->width = width;
1887 self->height = height;
1888 }
1889 static PyObject *wxRect_Get(wxRect *self){
1890 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1891 PyObject* tup = PyTuple_New(4);
1892 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1893 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1894 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1895 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1896 wxPyEndBlockThreads(blocked);
1897 return tup;
1898 }
1899
1900 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1901 wxRegion reg1(*r1);
1902 wxRegion reg2(*r2);
1903 wxRect dest(0,0,0,0);
1904 PyObject* obj;
1905
1906 reg1.Intersect(reg2);
1907 dest = reg1.GetBox();
1908
1909 if (dest != wxRect(0,0,0,0)) {
1910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1911 wxRect* newRect = new wxRect(dest);
1912 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1913 wxPyEndBlockThreads(blocked);
1914 return obj;
1915 }
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919
1920
1921 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1922 PyObject* o2;
1923 PyObject* o3;
1924
1925 if (!target) {
1926 target = o;
1927 } else if (target == Py_None) {
1928 Py_DECREF(Py_None);
1929 target = o;
1930 } else {
1931 if (!PyTuple_Check(target)) {
1932 o2 = target;
1933 target = PyTuple_New(1);
1934 PyTuple_SetItem(target, 0, o2);
1935 }
1936 o3 = PyTuple_New(1);
1937 PyTuple_SetItem(o3, 0, o);
1938
1939 o2 = target;
1940 target = PySequence_Concat(o2, o3);
1941 Py_DECREF(o2);
1942 Py_DECREF(o3);
1943 }
1944 return target;
1945 }
1946
1947
1948 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1949 self->m_x = x;
1950 self->m_y = y;
1951 }
1952 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1954 PyObject* tup = PyTuple_New(2);
1955 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1956 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1957 wxPyEndBlockThreads(blocked);
1958 return tup;
1959 }
1960
1961 #include "wx/wxPython/pyistream.h"
1962
1963 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1964 wxInputStream* wxis = wxPyCBInputStream::create(p);
1965 if (wxis)
1966 return new wxPyInputStream(wxis);
1967 else
1968 return NULL;
1969 }
1970
1971 SWIGINTERNSHORT PyObject*
1972 SWIG_From_char(char c)
1973 {
1974 return PyString_FromStringAndSize(&c,1);
1975 }
1976
1977
1978 SWIGINTERNSHORT PyObject*
1979 SWIG_From_unsigned_SS_long(unsigned long value)
1980 {
1981 return (value > LONG_MAX) ?
1982 PyLong_FromUnsignedLong(value)
1983 : PyInt_FromLong((long)(value));
1984 }
1985
1986
1987 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1988 SWIGINTERN int
1989 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1990 {
1991 static swig_type_info* pchar_info = 0;
1992 char* vptr = 0;
1993 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1994 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1995 if (cptr) *cptr = vptr;
1996 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1997 return SWIG_OLDOBJ;
1998 } else {
1999 PyErr_Clear();
2000 if (PyString_Check(obj)) {
2001 if (cptr) {
2002 *cptr = PyString_AS_STRING(obj);
2003 if (psize) {
2004 *psize = PyString_GET_SIZE(obj) + 1;
2005 }
2006 }
2007 return SWIG_PYSTR;
2008 }
2009 }
2010 if (cptr) {
2011 SWIG_type_error("char *", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERN int
2018 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2019 {
2020 char* cptr; size_t csize;
2021 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2022 /* in C you can do:
2023
2024 char x[5] = "hello";
2025
2026 ie, assing the array using an extra '0' char.
2027 */
2028 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2029 if (csize <= size) {
2030 if (val) {
2031 if (csize) memcpy(val, cptr, csize);
2032 if (csize < size) memset(val + csize, 0, size - csize);
2033 }
2034 return 1;
2035 }
2036 }
2037 if (val) {
2038 PyErr_Format(PyExc_TypeError,
2039 "a char array of maximum size %lu is expected",
2040 (unsigned long) size);
2041 }
2042 return 0;
2043 }
2044
2045
2046 SWIGINTERN int
2047 SWIG_AsVal_char(PyObject *obj, char *val)
2048 {
2049 const char* errmsg = val ? "char" : (char*)0;
2050 long v;
2051 if (SWIG_AsVal_long(obj, &v)) {
2052 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2053 if (val) *val = (char)(v);
2054 return 1;
2055 } else {
2056 return 0;
2057 }
2058 } else {
2059 PyErr_Clear();
2060 return SWIG_AsCharArray(obj, val, 1);
2061 }
2062 }
2063
2064
2065 SWIGINTERNSHORT char
2066 SWIG_As_char(PyObject* obj)
2067 {
2068 char v;
2069 if (!SWIG_AsVal_char(obj, &v)) {
2070 /*
2071 this is needed to make valgrind/purify happier.
2072 */
2073 memset((void*)&v, 0, sizeof(char));
2074 }
2075 return v;
2076 }
2077
2078
2079 SWIGINTERNSHORT int
2080 SWIG_Check_char(PyObject* obj)
2081 {
2082 return SWIG_AsVal_char(obj, (char*)0);
2083 }
2084
2085
2086 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2087 #define SWIG_From_long PyInt_FromLong
2088 /*@@*/
2089
2090 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2091 // We use only strings for the streams, not unicode
2092 PyObject* str = PyObject_Str(obj);
2093 if (! str) {
2094 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2095 return;
2096 }
2097 self->Write(PyString_AS_STRING(str),
2098 PyString_GET_SIZE(str));
2099 Py_DECREF(str);
2100 }
2101
2102 #include "wx/wxPython/pyistream.h"
2103
2104
2105 class wxPyFileSystemHandler : public wxFileSystemHandler
2106 {
2107 public:
2108 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2109
2110 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2111 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2112 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2113 DEC_PYCALLBACK_STRING__pure(FindNext);
2114
2115 wxString GetProtocol(const wxString& location) {
2116 return wxFileSystemHandler::GetProtocol(location);
2117 }
2118
2119 wxString GetLeftLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetLeftLocation(location);
2121 }
2122
2123 wxString GetAnchor(const wxString& location) {
2124 return wxFileSystemHandler::GetAnchor(location);
2125 }
2126
2127 wxString GetRightLocation(const wxString& location) {
2128 return wxFileSystemHandler::GetRightLocation(location);
2129 }
2130
2131 wxString GetMimeTypeFromExt(const wxString& location) {
2132 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2133 }
2134
2135 PYPRIVATE;
2136 };
2137
2138
2139 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2140 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2141 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2142 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2143
2144
2145 SWIGINTERN int
2146 SWIG_AsVal_bool(PyObject *obj, bool *val)
2147 {
2148 if (obj == Py_True) {
2149 if (val) *val = true;
2150 return 1;
2151 }
2152 if (obj == Py_False) {
2153 if (val) *val = false;
2154 return 1;
2155 }
2156 int res = 0;
2157 if (SWIG_AsVal_int(obj, &res)) {
2158 if (val) *val = res ? true : false;
2159 return 1;
2160 } else {
2161 PyErr_Clear();
2162 }
2163 if (val) {
2164 SWIG_type_error("bool", obj);
2165 }
2166 return 0;
2167 }
2168
2169
2170 SWIGINTERNSHORT bool
2171 SWIG_As_bool(PyObject* obj)
2172 {
2173 bool v;
2174 if (!SWIG_AsVal_bool(obj, &v)) {
2175 /*
2176 this is needed to make valgrind/purify happier.
2177 */
2178 memset((void*)&v, 0, sizeof(bool));
2179 }
2180 return v;
2181 }
2182
2183
2184 SWIGINTERNSHORT int
2185 SWIG_Check_bool(PyObject* obj)
2186 {
2187 return SWIG_AsVal_bool(obj, (bool*)0);
2188 }
2189
2190 static wxString FileSystem_URLToFileName(wxString const &url){
2191 wxFileName fname = wxFileSystem::URLToFileName(url);
2192 return fname.GetFullPath();
2193 }
2194
2195 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2196 wxImage& image,
2197 long type) {
2198 wxMemoryFSHandler::AddFile(filename, image, type);
2199 }
2200
2201 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2202 const wxBitmap& bitmap,
2203 long type) {
2204 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2205 }
2206
2207 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2208 PyObject* data) {
2209 if (! PyString_Check(data)) {
2210 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2211 "Expected string object"));
2212 return;
2213 }
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 void* ptr = (void*)PyString_AsString(data);
2217 size_t size = PyString_Size(data);
2218 wxPyEndBlockThreads(blocked);
2219
2220 wxMemoryFSHandler::AddFile(filename, ptr, size);
2221 }
2222
2223
2224 #include "wx/wxPython/pyistream.h"
2225
2226
2227 SWIGINTERN int
2228 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2229 {
2230 long v = 0;
2231 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2232 SWIG_type_error("unsigned number", obj);
2233 }
2234 else if (val)
2235 *val = (unsigned long)v;
2236 return 1;
2237 }
2238
2239
2240 SWIGINTERNSHORT int
2241 SWIG_CheckUnsignedLongInRange(unsigned long value,
2242 unsigned long max_value,
2243 const char *errmsg)
2244 {
2245 if (value > max_value) {
2246 if (errmsg) {
2247 PyErr_Format(PyExc_OverflowError,
2248 "value %lu is greater than '%s' minimum %lu",
2249 value, errmsg, max_value);
2250 }
2251 return 0;
2252 }
2253 return 1;
2254 }
2255
2256
2257 SWIGINTERN int
2258 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2259 {
2260 const char* errmsg = val ? "unsigned char" : (char*)0;
2261 unsigned long v;
2262 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2263 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2264 if (val) *val = (unsigned char)(v);
2265 return 1;
2266 } else {
2267 return 0;
2268 }
2269 } else {
2270 PyErr_Clear();
2271 }
2272 if (val) {
2273 SWIG_type_error(errmsg, obj);
2274 }
2275 return 0;
2276 }
2277
2278
2279 SWIGINTERNSHORT unsigned char
2280 SWIG_As_unsigned_SS_char(PyObject* obj)
2281 {
2282 unsigned char v;
2283 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2284 /*
2285 this is needed to make valgrind/purify happier.
2286 */
2287 memset((void*)&v, 0, sizeof(unsigned char));
2288 }
2289 return v;
2290 }
2291
2292
2293 SWIGINTERNSHORT int
2294 SWIG_Check_unsigned_SS_char(PyObject* obj)
2295 {
2296 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2297 }
2298
2299
2300 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2301 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2302 /*@@*/
2303
2304
2305
2306 SWIGINTERNSHORT unsigned long
2307 SWIG_As_unsigned_SS_long(PyObject* obj)
2308 {
2309 unsigned long v;
2310 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2311 /*
2312 this is needed to make valgrind/purify happier.
2313 */
2314 memset((void*)&v, 0, sizeof(unsigned long));
2315 }
2316 return v;
2317 }
2318
2319
2320 SWIGINTERNSHORT int
2321 SWIG_Check_unsigned_SS_long(PyObject* obj)
2322 {
2323 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2324 }
2325
2326 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2327 wxImageHistogramEntry e = (*self)[key];
2328 return e.value;
2329 }
2330 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2331 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2332 wxImageHistogramEntry e = (*self)[key];
2333 return e.value;
2334 }
2335 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2336 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2337 colour.Green(),
2338 colour.Blue());
2339 wxImageHistogramEntry e = (*self)[key];
2340 return e.value;
2341 }
2342
2343 typedef unsigned char* buffer;
2344
2345 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2346 if (width > 0 && height > 0)
2347 return new wxImage(width, height, clear);
2348 else
2349 return new wxImage;
2350 }
2351 static wxImage *new_wxImage(wxBitmap const &bitmap){
2352 return new wxImage(bitmap.ConvertToImage());
2353 }
2354 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2355 if (DATASIZE != width*height*3) {
2356 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2357 return NULL;
2358 }
2359
2360 // Copy the source data so the wxImage can clean it up later
2361 buffer copy = (buffer)malloc(DATASIZE);
2362 if (copy == NULL) {
2363 wxPyBLOCK_THREADS(PyErr_NoMemory());
2364 return NULL;
2365 }
2366 memcpy(copy, data, DATASIZE);
2367 return new wxImage(width, height, copy, false);
2368 }
2369 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2370 if (DATASIZE != width*height*3) {
2371 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2372 return NULL;
2373 }
2374 if (ALPHASIZE != width*height) {
2375 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2376 return NULL;
2377 }
2378
2379 // Copy the source data so the wxImage can clean it up later
2380 buffer dcopy = (buffer)malloc(DATASIZE);
2381 if (dcopy == NULL) {
2382 wxPyBLOCK_THREADS(PyErr_NoMemory());
2383 return NULL;
2384 }
2385 memcpy(dcopy, data, DATASIZE);
2386
2387 buffer acopy = (buffer)malloc(ALPHASIZE);
2388 if (acopy == NULL) {
2389 wxPyBLOCK_THREADS(PyErr_NoMemory());
2390 return NULL;
2391 }
2392 memcpy(acopy, alpha, ALPHASIZE);
2393
2394 return new wxImage(width, height, dcopy, acopy, false);
2395 }
2396 static wxSize wxImage_GetSize(wxImage *self){
2397 wxSize size(self->GetWidth(), self->GetHeight());
2398 return size;
2399 }
2400 static PyObject *wxImage_GetData(wxImage *self){
2401 buffer data = self->GetData();
2402 int len = self->GetWidth() * self->GetHeight() * 3;
2403 PyObject* rv;
2404 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2405 return rv;
2406 }
2407 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2408 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2409 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2410 return;
2411 }
2412 buffer copy = (buffer)malloc(DATASIZE);
2413 if (copy == NULL) {
2414 wxPyBLOCK_THREADS(PyErr_NoMemory());
2415 return;
2416 }
2417 memcpy(copy, data, DATASIZE);
2418 self->SetData(copy, false);
2419 // wxImage takes ownership of copy...
2420 }
2421 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2422 buffer data = self->GetData();
2423 int len = self->GetWidth() * self->GetHeight() * 3;
2424 PyObject* rv;
2425 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2426 return rv;
2427 }
2428 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2429 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2430 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2431 return;
2432 }
2433 self->SetData(data, true);
2434 }
2435 static PyObject *wxImage_GetAlphaData(wxImage *self){
2436 buffer data = self->GetAlpha();
2437 if (! data) {
2438 RETURN_NONE();
2439 } else {
2440 int len = self->GetWidth() * self->GetHeight();
2441 PyObject* rv;
2442 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2443 return rv;
2444 }
2445 }
2446 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2447 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2448 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2449 return;
2450 }
2451 buffer acopy = (buffer)malloc(ALPHASIZE);
2452 if (acopy == NULL) {
2453 wxPyBLOCK_THREADS(PyErr_NoMemory());
2454 return;
2455 }
2456 memcpy(acopy, alpha, ALPHASIZE);
2457 self->SetAlpha(acopy, false);
2458 // wxImage takes ownership of acopy...
2459 }
2460 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2461 buffer data = self->GetAlpha();
2462 int len = self->GetWidth() * self->GetHeight();
2463 PyObject* rv;
2464 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2465 return rv;
2466 }
2467 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2468 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2469 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2470 return;
2471 }
2472 self->SetAlpha(alpha, true);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2633
2634 void wxApp_CleanUp() {
2635 __wxPyCleanup();
2636 }
2637
2638
2639 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2640
2641
2642 SWIGINTERNSHORT int
2643 SWIG_AsCharPtr(PyObject *obj, char **val)
2644 {
2645 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2646 return 1;
2647 }
2648 if (val) {
2649 PyErr_Clear();
2650 SWIG_type_error("char *", obj);
2651 }
2652 return 0;
2653 }
2654
2655
2656 SWIGINTERN PyObject *
2657 SWIG_FromCharPtr(const char* cptr)
2658 {
2659 if (cptr) {
2660 size_t size = strlen(cptr);
2661 if (size > INT_MAX) {
2662 return SWIG_NewPointerObj((char*)(cptr),
2663 SWIG_TypeQuery("char *"), 0);
2664 } else {
2665 if (size != 0) {
2666 return PyString_FromStringAndSize(cptr, size);
2667 } else {
2668 return PyString_FromString(cptr);
2669 }
2670 }
2671 }
2672 Py_INCREF(Py_None);
2673 return Py_None;
2674 }
2675
2676
2677 #ifdef __WXMAC__
2678
2679 // A dummy class that raises an exception if used...
2680 class wxEventLoop
2681 {
2682 public:
2683 wxEventLoop() { wxPyRaiseNotImplemented(); }
2684 int Run() { return 0; }
2685 void Exit(int rc = 0) {}
2686 bool Pending() const { return false; }
2687 bool Dispatch() { return false; }
2688 bool IsRunning() const { return false; }
2689 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2690 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2691 };
2692
2693 #else
2694
2695 #include <wx/evtloop.h>
2696
2697 #endif
2698
2699
2700
2701 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2702 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2703 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2704 static PyObject *wxWindow_GetChildren(wxWindow *self){
2705 wxWindowList& list = self->GetChildren();
2706 return wxPy_ConvertList(&list);
2707 }
2708 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2709 #if wxUSE_HOTKEY
2710 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2711 #else
2712 return false;
2713 #endif
2714 }
2715 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2716
2717
2718
2719 return false;
2720
2721 }
2722 static long wxWindow_GetHandle(wxWindow *self){
2723 return wxPyGetWinHandle(self);
2724 }
2725 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2726 self->AssociateHandle((WXWidget)handle);
2727 }
2728
2729 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2730 return wxWindow::FindWindowById(id, parent);
2731 }
2732
2733 wxWindow* wxFindWindowByName( const wxString& name,
2734 const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowByName(name, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByLabel( const wxString& label,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByLabel(label, parent);
2741 }
2742
2743
2744 #ifdef __WXMSW__
2745 #include <wx/msw/private.h> // to get wxGetWindowId
2746 #endif
2747
2748
2749 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2750 #ifdef __WXMSW__
2751 WXHWND hWnd = (WXHWND)_hWnd;
2752 long id = wxGetWindowId(hWnd);
2753 wxWindow* win = new wxWindow;
2754 parent->AddChild(win);
2755 win->SetEventHandler(win);
2756 win->SetHWND(hWnd);
2757 win->SetId(id);
2758 win->SubclassWin(hWnd);
2759 win->AdoptAttributesFromHWND();
2760 win->SetupColours();
2761 return win;
2762 #else
2763 wxPyRaiseNotImplemented();
2764 return NULL;
2765 #endif
2766 }
2767
2768
2769 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2772
2773 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2774
2775 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2776 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2777 wxMenuItemList& list = self->GetMenuItems();
2778 return wxPy_ConvertList(&list);
2779 }
2780 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2781 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2782 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2783 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2784 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2785 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2786 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2787 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2788 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2789 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2790 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2791 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2792 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2793 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2794 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2795 static const wxString wxPyControlNameStr(wxControlNameStr);
2796 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2797 if (clientData) {
2798 wxPyClientData* data = new wxPyClientData(clientData);
2799 return self->Append(item, data);
2800 } else
2801 return self->Append(item);
2802 }
2803 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2804 if (clientData) {
2805 wxPyClientData* data = new wxPyClientData(clientData);
2806 return self->Insert(item, pos, data);
2807 } else
2808 return self->Insert(item, pos);
2809 }
2810 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2811 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2812 if (data) {
2813 Py_INCREF(data->m_obj);
2814 return data->m_obj;
2815 } else {
2816 Py_INCREF(Py_None);
2817 return Py_None;
2818 }
2819 }
2820 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2821 wxPyClientData* data = new wxPyClientData(clientData);
2822 self->SetClientObject(n, data);
2823 }
2824
2825
2826 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2827 wxPyUserData* data = NULL;
2828 if ( userData ) {
2829 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2830 data = new wxPyUserData(userData);
2831 wxPyEndBlockThreads(blocked);
2832 }
2833 return new wxSizerItem(window, proportion, flag, border, data);
2834 }
2835 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2836 wxPyUserData* data = NULL;
2837 if ( userData ) {
2838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2839 data = new wxPyUserData(userData);
2840 wxPyEndBlockThreads(blocked);
2841 }
2842 return new wxSizerItem(width, height, proportion, flag, border, data);
2843 }
2844 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2845 wxPyUserData* data = NULL;
2846 if ( userData ) {
2847 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2848 data = new wxPyUserData(userData);
2849 wxPyEndBlockThreads(blocked);
2850 }
2851 return new wxSizerItem(sizer, proportion, flag, border, data);
2852 }
2853
2854 #include <float.h>
2855 SWIGINTERN int
2856 SWIG_CheckDoubleInRange(double value, double min_value,
2857 double max_value, const char* errmsg)
2858 {
2859 if (value < min_value) {
2860 if (errmsg) {
2861 PyErr_Format(PyExc_OverflowError,
2862 "value %g is less than %s minimum %g",
2863 value, errmsg, min_value);
2864 }
2865 return 0;
2866 } else if (value > max_value) {
2867 if (errmsg) {
2868 PyErr_Format(PyExc_OverflowError,
2869 "value %g is greater than %s maximum %g",
2870 value, errmsg, max_value);
2871 }
2872 return 0;
2873 }
2874 return 1;
2875 }
2876
2877
2878 SWIGINTERN int
2879 SWIG_AsVal_float(PyObject *obj, float *val)
2880 {
2881 const char* errmsg = val ? "float" : (char*)0;
2882 double v;
2883 if (SWIG_AsVal_double(obj, &v)) {
2884 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2885 if (val) *val = (float)(v);
2886 return 1;
2887 } else {
2888 return 0;
2889 }
2890 } else {
2891 PyErr_Clear();
2892 }
2893 if (val) {
2894 SWIG_type_error(errmsg, obj);
2895 }
2896 return 0;
2897 }
2898
2899
2900 SWIGINTERNSHORT float
2901 SWIG_As_float(PyObject* obj)
2902 {
2903 float v;
2904 if (!SWIG_AsVal_float(obj, &v)) {
2905 /*
2906 this is needed to make valgrind/purify happier.
2907 */
2908 memset((void*)&v, 0, sizeof(float));
2909 }
2910 return v;
2911 }
2912
2913
2914 SWIGINTERNSHORT int
2915 SWIG_Check_float(PyObject* obj)
2916 {
2917 return SWIG_AsVal_float(obj, (float*)0);
2918 }
2919
2920
2921 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2922 #define SWIG_From_float PyFloat_FromDouble
2923 /*@@*/
2924
2925 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2926 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2927 if (data) {
2928 Py_INCREF(data->m_obj);
2929 return data->m_obj;
2930 } else {
2931 Py_INCREF(Py_None);
2932 return Py_None;
2933 }
2934 }
2935
2936 // Figure out the type of the sizer item
2937
2938 struct wxPySizerItemInfo {
2939 wxPySizerItemInfo()
2940 : window(NULL), sizer(NULL), gotSize(false),
2941 size(wxDefaultSize), gotPos(false), pos(-1)
2942 {}
2943
2944 wxWindow* window;
2945 wxSizer* sizer;
2946 bool gotSize;
2947 wxSize size;
2948 bool gotPos;
2949 int pos;
2950 };
2951
2952 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2953
2954 wxPySizerItemInfo info;
2955 wxSize size;
2956 wxSize* sizePtr = &size;
2957
2958 // Find out what the type of the item is
2959 // try wxWindow
2960 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2961 PyErr_Clear();
2962 info.window = NULL;
2963
2964 // try wxSizer
2965 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2966 PyErr_Clear();
2967 info.sizer = NULL;
2968
2969 // try wxSize or (w,h)
2970 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2971 info.size = *sizePtr;
2972 info.gotSize = true;
2973 }
2974
2975 // or a single int
2976 if (checkIdx && PyInt_Check(item)) {
2977 info.pos = PyInt_AsLong(item);
2978 info.gotPos = true;
2979 }
2980 }
2981 }
2982
2983 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2984 // no expected type, figure out what kind of error message to generate
2985 if ( !checkSize && !checkIdx )
2986 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2987 else if ( checkSize && !checkIdx )
2988 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2989 else if ( !checkSize && checkIdx)
2990 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2991 else
2992 // can this one happen?
2993 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2994 }
2995
2996 return info;
2997 }
2998
2999 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3000 if (!self->GetClientObject())
3001 self->SetClientObject(new wxPyOORClientData(_self));
3002 }
3003 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3004
3005 wxPyUserData* data = NULL;
3006 wxPyBlock_t 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 Add method if a valid item type was found
3013 if ( info.window )
3014 return self->Add(info.window, proportion, flag, border, data);
3015 else if ( info.sizer )
3016 return self->Add(info.sizer, proportion, flag, border, data);
3017 else if (info.gotSize)
3018 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3019 proportion, flag, border, data);
3020 else
3021 return NULL;
3022 }
3023 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3024
3025 wxPyUserData* data = NULL;
3026 wxPyBlock_t 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 Insert method if a valid item type was found
3033 if ( info.window )
3034 return self->Insert(before, info.window, proportion, flag, border, data);
3035 else if ( info.sizer )
3036 return self->Insert(before, info.sizer, proportion, flag, border, data);
3037 else if (info.gotSize)
3038 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3039 proportion, flag, border, data);
3040 else
3041 return NULL;
3042 }
3043 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3044
3045 wxPyUserData* data = NULL;
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3048 if ( userData && (info.window || info.sizer || info.gotSize) )
3049 data = new wxPyUserData(userData);
3050 wxPyEndBlockThreads(blocked);
3051
3052 // Now call the real Prepend method if a valid item type was found
3053 if ( info.window )
3054 return self->Prepend(info.window, proportion, flag, border, data);
3055 else if ( info.sizer )
3056 return self->Prepend(info.sizer, proportion, flag, border, data);
3057 else if (info.gotSize)
3058 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3059 proportion, flag, border, data);
3060 else
3061 return NULL;
3062 }
3063 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3065 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3066 wxPyEndBlockThreads(blocked);
3067 if ( info.window )
3068 return self->Remove(info.window);
3069 else if ( info.sizer )
3070 return self->Remove(info.sizer);
3071 else if ( info.gotPos )
3072 return self->Remove(info.pos);
3073 else
3074 return false;
3075 }
3076 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3079 wxPyEndBlockThreads(blocked);
3080 if ( info.window )
3081 return self->Detach(info.window);
3082 else if ( info.sizer )
3083 return self->Detach(info.sizer);
3084 else if ( info.gotPos )
3085 return self->Detach(info.pos);
3086 else
3087 return false;
3088 }
3089 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3092 wxPyEndBlockThreads(blocked);
3093 if ( info.window )
3094 return self->GetItem(info.window);
3095 else if ( info.sizer )
3096 return self->GetItem(info.sizer);
3097 else if ( info.gotPos )
3098 return self->GetItem(info.pos);
3099 else
3100 return NULL;
3101 }
3102 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3105 wxPyEndBlockThreads(blocked);
3106 if ( info.window )
3107 self->SetItemMinSize(info.window, size);
3108 else if ( info.sizer )
3109 self->SetItemMinSize(info.sizer, size);
3110 else if ( info.gotPos )
3111 self->SetItemMinSize(info.pos, size);
3112 }
3113 static PyObject *wxSizer_GetChildren(wxSizer *self){
3114 wxSizerItemList& list = self->GetChildren();
3115 return wxPy_ConvertList(&list);
3116 }
3117 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3119 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3120 wxPyEndBlockThreads(blocked);
3121 if ( info.window )
3122 return self->Show(info.window, show, recursive);
3123 else if ( info.sizer )
3124 return self->Show(info.sizer, show, recursive);
3125 else if ( info.gotPos )
3126 return self->Show(info.pos, show);
3127 else
3128 return false;
3129 }
3130 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3131 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3132 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3133 wxPyEndBlockThreads(blocked);
3134 if ( info.window )
3135 return self->IsShown(info.window);
3136 else if ( info.sizer )
3137 return self->IsShown(info.sizer);
3138 else if ( info.gotPos )
3139 return self->IsShown(info.pos);
3140 else
3141 return false;
3142 }
3143
3144 // See pyclasses.h
3145 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3146 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3147 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3148
3149
3150
3151
3152 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3153 {
3154 if (source == Py_None) {
3155 **obj = wxGBPosition(-1,-1);
3156 return true;
3157 }
3158 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3159 }
3160
3161 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3162 {
3163 if (source == Py_None) {
3164 **obj = wxGBSpan(-1,-1);
3165 return true;
3166 }
3167 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3168 }
3169
3170
3171 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3172 self->SetRow(row);
3173 self->SetCol(col);
3174 }
3175 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3177 PyObject* tup = PyTuple_New(2);
3178 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3179 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3180 wxPyEndBlockThreads(blocked);
3181 return tup;
3182 }
3183 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3184 self->SetRowspan(rowspan);
3185 self->SetColspan(colspan);
3186 }
3187 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3189 PyObject* tup = PyTuple_New(2);
3190 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3191 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3192 wxPyEndBlockThreads(blocked);
3193 return tup;
3194 }
3195 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3196 wxPyUserData* data = NULL;
3197 if ( userData ) {
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 data = new wxPyUserData(userData);
3200 wxPyEndBlockThreads(blocked);
3201 }
3202 return new wxGBSizerItem(window, pos, span, flag, border, data);
3203 }
3204 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3205 wxPyUserData* data = NULL;
3206 if ( userData ) {
3207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3208 data = new wxPyUserData(userData);
3209 wxPyEndBlockThreads(blocked);
3210 }
3211 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3212 }
3213 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3214 wxPyUserData* data = NULL;
3215 if ( userData ) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 data = new wxPyUserData(userData);
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3221 }
3222 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3223 int row, col;
3224 self->GetEndPos(row, col);
3225 return wxGBPosition(row, col);
3226 }
3227 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3228
3229 wxPyUserData* data = NULL;
3230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3231 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3232 if ( userData && (info.window || info.sizer || info.gotSize) )
3233 data = new wxPyUserData(userData);
3234 wxPyEndBlockThreads(blocked);
3235
3236 // Now call the real Add method if a valid item type was found
3237 if ( info.window )
3238 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3239 else if ( info.sizer )
3240 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3241 else if (info.gotSize)
3242 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3243 pos, span, flag, border, data);
3244 return NULL;
3245 }
3246
3247
3248 #ifdef __cplusplus
3249 extern "C" {
3250 #endif
3251 static int _wrap_EmptyString_set(PyObject *) {
3252 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3253 return 1;
3254 }
3255
3256
3257 static PyObject *_wrap_EmptyString_get(void) {
3258 PyObject *pyobj;
3259
3260 {
3261 #if wxUSE_UNICODE
3262 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3263 #else
3264 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3265 #endif
3266 }
3267 return pyobj;
3268 }
3269
3270
3271 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxObject *arg1 = (wxObject *) 0 ;
3274 wxString result;
3275 PyObject * obj0 = 0 ;
3276 char *kwnames[] = {
3277 (char *) "self", NULL
3278 };
3279
3280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3282 if (SWIG_arg_fail(1)) SWIG_fail;
3283 {
3284 PyThreadState* __tstate = wxPyBeginAllowThreads();
3285 result = wxObject_GetClassName(arg1);
3286
3287 wxPyEndAllowThreads(__tstate);
3288 if (PyErr_Occurred()) SWIG_fail;
3289 }
3290 {
3291 #if wxUSE_UNICODE
3292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3293 #else
3294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3295 #endif
3296 }
3297 return resultobj;
3298 fail:
3299 return NULL;
3300 }
3301
3302
3303 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxObject *arg1 = (wxObject *) 0 ;
3306 PyObject * obj0 = 0 ;
3307 char *kwnames[] = {
3308 (char *) "self", NULL
3309 };
3310
3311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3313 if (SWIG_arg_fail(1)) SWIG_fail;
3314 {
3315 PyThreadState* __tstate = wxPyBeginAllowThreads();
3316 wxObject_Destroy(arg1);
3317
3318 wxPyEndAllowThreads(__tstate);
3319 if (PyErr_Occurred()) SWIG_fail;
3320 }
3321 Py_INCREF(Py_None); resultobj = Py_None;
3322 return resultobj;
3323 fail:
3324 return NULL;
3325 }
3326
3327
3328 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3329 PyObject *obj;
3330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3331 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3332 Py_INCREF(obj);
3333 return Py_BuildValue((char *)"");
3334 }
3335 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3336 PyObject *resultobj;
3337 wxSize *arg1 = (wxSize *) 0 ;
3338 int arg2 ;
3339 PyObject * obj0 = 0 ;
3340 PyObject * obj1 = 0 ;
3341 char *kwnames[] = {
3342 (char *) "self",(char *) "x", NULL
3343 };
3344
3345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3347 if (SWIG_arg_fail(1)) SWIG_fail;
3348 {
3349 arg2 = (int)(SWIG_As_int(obj1));
3350 if (SWIG_arg_fail(2)) SWIG_fail;
3351 }
3352 if (arg1) (arg1)->x = arg2;
3353
3354 Py_INCREF(Py_None); resultobj = Py_None;
3355 return resultobj;
3356 fail:
3357 return NULL;
3358 }
3359
3360
3361 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3362 PyObject *resultobj;
3363 wxSize *arg1 = (wxSize *) 0 ;
3364 int result;
3365 PyObject * obj0 = 0 ;
3366 char *kwnames[] = {
3367 (char *) "self", NULL
3368 };
3369
3370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3372 if (SWIG_arg_fail(1)) SWIG_fail;
3373 result = (int) ((arg1)->x);
3374
3375 {
3376 resultobj = SWIG_From_int((int)(result));
3377 }
3378 return resultobj;
3379 fail:
3380 return NULL;
3381 }
3382
3383
3384 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3385 PyObject *resultobj;
3386 wxSize *arg1 = (wxSize *) 0 ;
3387 int arg2 ;
3388 PyObject * obj0 = 0 ;
3389 PyObject * obj1 = 0 ;
3390 char *kwnames[] = {
3391 (char *) "self",(char *) "y", NULL
3392 };
3393
3394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3396 if (SWIG_arg_fail(1)) SWIG_fail;
3397 {
3398 arg2 = (int)(SWIG_As_int(obj1));
3399 if (SWIG_arg_fail(2)) SWIG_fail;
3400 }
3401 if (arg1) (arg1)->y = arg2;
3402
3403 Py_INCREF(Py_None); resultobj = Py_None;
3404 return resultobj;
3405 fail:
3406 return NULL;
3407 }
3408
3409
3410 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj;
3412 wxSize *arg1 = (wxSize *) 0 ;
3413 int result;
3414 PyObject * obj0 = 0 ;
3415 char *kwnames[] = {
3416 (char *) "self", NULL
3417 };
3418
3419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3421 if (SWIG_arg_fail(1)) SWIG_fail;
3422 result = (int) ((arg1)->y);
3423
3424 {
3425 resultobj = SWIG_From_int((int)(result));
3426 }
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 int arg1 = (int) 0 ;
3436 int arg2 = (int) 0 ;
3437 wxSize *result;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "w",(char *) "h", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3445 if (obj0) {
3446 {
3447 arg1 = (int)(SWIG_As_int(obj0));
3448 if (SWIG_arg_fail(1)) SWIG_fail;
3449 }
3450 }
3451 if (obj1) {
3452 {
3453 arg2 = (int)(SWIG_As_int(obj1));
3454 if (SWIG_arg_fail(2)) SWIG_fail;
3455 }
3456 }
3457 {
3458 PyThreadState* __tstate = wxPyBeginAllowThreads();
3459 result = (wxSize *)new wxSize(arg1,arg2);
3460
3461 wxPyEndAllowThreads(__tstate);
3462 if (PyErr_Occurred()) SWIG_fail;
3463 }
3464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3465 return resultobj;
3466 fail:
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxSize *arg1 = (wxSize *) 0 ;
3474 PyObject * obj0 = 0 ;
3475 char *kwnames[] = {
3476 (char *) "self", NULL
3477 };
3478
3479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3481 if (SWIG_arg_fail(1)) SWIG_fail;
3482 {
3483 PyThreadState* __tstate = wxPyBeginAllowThreads();
3484 delete arg1;
3485
3486 wxPyEndAllowThreads(__tstate);
3487 if (PyErr_Occurred()) SWIG_fail;
3488 }
3489 Py_INCREF(Py_None); resultobj = Py_None;
3490 return resultobj;
3491 fail:
3492 return NULL;
3493 }
3494
3495
3496 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3497 PyObject *resultobj;
3498 wxSize *arg1 = (wxSize *) 0 ;
3499 wxSize *arg2 = 0 ;
3500 bool result;
3501 wxSize temp2 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 char *kwnames[] = {
3505 (char *) "self",(char *) "sz", NULL
3506 };
3507
3508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3510 if (SWIG_arg_fail(1)) SWIG_fail;
3511 {
3512 arg2 = &temp2;
3513 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3514 }
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 {
3523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3524 }
3525 return resultobj;
3526 fail:
3527 return NULL;
3528 }
3529
3530
3531 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3532 PyObject *resultobj;
3533 wxSize *arg1 = (wxSize *) 0 ;
3534 wxSize *arg2 = 0 ;
3535 bool result;
3536 wxSize temp2 ;
3537 PyObject * obj0 = 0 ;
3538 PyObject * obj1 = 0 ;
3539 char *kwnames[] = {
3540 (char *) "self",(char *) "sz", NULL
3541 };
3542
3543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3545 if (SWIG_arg_fail(1)) SWIG_fail;
3546 {
3547 arg2 = &temp2;
3548 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3549 }
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 {
3558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3559 }
3560 return resultobj;
3561 fail:
3562 return NULL;
3563 }
3564
3565
3566 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3567 PyObject *resultobj;
3568 wxSize *arg1 = (wxSize *) 0 ;
3569 wxSize *arg2 = 0 ;
3570 wxSize result;
3571 wxSize temp2 ;
3572 PyObject * obj0 = 0 ;
3573 PyObject * obj1 = 0 ;
3574 char *kwnames[] = {
3575 (char *) "self",(char *) "sz", NULL
3576 };
3577
3578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 {
3582 arg2 = &temp2;
3583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3584 }
3585 {
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 result = (arg1)->operator +((wxSize const &)*arg2);
3588
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 {
3593 wxSize * resultptr;
3594 resultptr = new wxSize((wxSize &)(result));
3595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3596 }
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 wxSize *arg1 = (wxSize *) 0 ;
3606 wxSize *arg2 = 0 ;
3607 wxSize result;
3608 wxSize temp2 ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 char *kwnames[] = {
3612 (char *) "self",(char *) "sz", NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3617 if (SWIG_arg_fail(1)) SWIG_fail;
3618 {
3619 arg2 = &temp2;
3620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3621 }
3622 {
3623 PyThreadState* __tstate = wxPyBeginAllowThreads();
3624 result = (arg1)->operator -((wxSize const &)*arg2);
3625
3626 wxPyEndAllowThreads(__tstate);
3627 if (PyErr_Occurred()) SWIG_fail;
3628 }
3629 {
3630 wxSize * resultptr;
3631 resultptr = new wxSize((wxSize &)(result));
3632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3633 }
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3641 PyObject *resultobj;
3642 wxSize *arg1 = (wxSize *) 0 ;
3643 wxSize *arg2 = 0 ;
3644 wxSize temp2 ;
3645 PyObject * obj0 = 0 ;
3646 PyObject * obj1 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "self",(char *) "sz", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 {
3655 arg2 = &temp2;
3656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3657 }
3658 {
3659 PyThreadState* __tstate = wxPyBeginAllowThreads();
3660 (arg1)->IncTo((wxSize const &)*arg2);
3661
3662 wxPyEndAllowThreads(__tstate);
3663 if (PyErr_Occurred()) SWIG_fail;
3664 }
3665 Py_INCREF(Py_None); resultobj = Py_None;
3666 return resultobj;
3667 fail:
3668 return NULL;
3669 }
3670
3671
3672 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 wxSize *arg2 = 0 ;
3676 wxSize temp2 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "self",(char *) "sz", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 {
3687 arg2 = &temp2;
3688 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3689 }
3690 {
3691 PyThreadState* __tstate = wxPyBeginAllowThreads();
3692 (arg1)->DecTo((wxSize const &)*arg2);
3693
3694 wxPyEndAllowThreads(__tstate);
3695 if (PyErr_Occurred()) SWIG_fail;
3696 }
3697 Py_INCREF(Py_None); resultobj = Py_None;
3698 return resultobj;
3699 fail:
3700 return NULL;
3701 }
3702
3703
3704 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3705 PyObject *resultobj;
3706 wxSize *arg1 = (wxSize *) 0 ;
3707 int arg2 ;
3708 int arg3 ;
3709 PyObject * obj0 = 0 ;
3710 PyObject * obj1 = 0 ;
3711 PyObject * obj2 = 0 ;
3712 char *kwnames[] = {
3713 (char *) "self",(char *) "w",(char *) "h", NULL
3714 };
3715
3716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3718 if (SWIG_arg_fail(1)) SWIG_fail;
3719 {
3720 arg2 = (int)(SWIG_As_int(obj1));
3721 if (SWIG_arg_fail(2)) SWIG_fail;
3722 }
3723 {
3724 arg3 = (int)(SWIG_As_int(obj2));
3725 if (SWIG_arg_fail(3)) SWIG_fail;
3726 }
3727 {
3728 PyThreadState* __tstate = wxPyBeginAllowThreads();
3729 (arg1)->Set(arg2,arg3);
3730
3731 wxPyEndAllowThreads(__tstate);
3732 if (PyErr_Occurred()) SWIG_fail;
3733 }
3734 Py_INCREF(Py_None); resultobj = Py_None;
3735 return resultobj;
3736 fail:
3737 return NULL;
3738 }
3739
3740
3741 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3742 PyObject *resultobj;
3743 wxSize *arg1 = (wxSize *) 0 ;
3744 int arg2 ;
3745 PyObject * obj0 = 0 ;
3746 PyObject * obj1 = 0 ;
3747 char *kwnames[] = {
3748 (char *) "self",(char *) "w", NULL
3749 };
3750
3751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3753 if (SWIG_arg_fail(1)) SWIG_fail;
3754 {
3755 arg2 = (int)(SWIG_As_int(obj1));
3756 if (SWIG_arg_fail(2)) SWIG_fail;
3757 }
3758 {
3759 PyThreadState* __tstate = wxPyBeginAllowThreads();
3760 (arg1)->SetWidth(arg2);
3761
3762 wxPyEndAllowThreads(__tstate);
3763 if (PyErr_Occurred()) SWIG_fail;
3764 }
3765 Py_INCREF(Py_None); resultobj = Py_None;
3766 return resultobj;
3767 fail:
3768 return NULL;
3769 }
3770
3771
3772 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3773 PyObject *resultobj;
3774 wxSize *arg1 = (wxSize *) 0 ;
3775 int arg2 ;
3776 PyObject * obj0 = 0 ;
3777 PyObject * obj1 = 0 ;
3778 char *kwnames[] = {
3779 (char *) "self",(char *) "h", NULL
3780 };
3781
3782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3784 if (SWIG_arg_fail(1)) SWIG_fail;
3785 {
3786 arg2 = (int)(SWIG_As_int(obj1));
3787 if (SWIG_arg_fail(2)) SWIG_fail;
3788 }
3789 {
3790 PyThreadState* __tstate = wxPyBeginAllowThreads();
3791 (arg1)->SetHeight(arg2);
3792
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 Py_INCREF(Py_None); resultobj = Py_None;
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj;
3805 wxSize *arg1 = (wxSize *) 0 ;
3806 int result;
3807 PyObject * obj0 = 0 ;
3808 char *kwnames[] = {
3809 (char *) "self", NULL
3810 };
3811
3812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3814 if (SWIG_arg_fail(1)) SWIG_fail;
3815 {
3816 PyThreadState* __tstate = wxPyBeginAllowThreads();
3817 result = (int)((wxSize const *)arg1)->GetWidth();
3818
3819 wxPyEndAllowThreads(__tstate);
3820 if (PyErr_Occurred()) SWIG_fail;
3821 }
3822 {
3823 resultobj = SWIG_From_int((int)(result));
3824 }
3825 return resultobj;
3826 fail:
3827 return NULL;
3828 }
3829
3830
3831 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3832 PyObject *resultobj;
3833 wxSize *arg1 = (wxSize *) 0 ;
3834 int result;
3835 PyObject * obj0 = 0 ;
3836 char *kwnames[] = {
3837 (char *) "self", NULL
3838 };
3839
3840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3842 if (SWIG_arg_fail(1)) SWIG_fail;
3843 {
3844 PyThreadState* __tstate = wxPyBeginAllowThreads();
3845 result = (int)((wxSize const *)arg1)->GetHeight();
3846
3847 wxPyEndAllowThreads(__tstate);
3848 if (PyErr_Occurred()) SWIG_fail;
3849 }
3850 {
3851 resultobj = SWIG_From_int((int)(result));
3852 }
3853 return resultobj;
3854 fail:
3855 return NULL;
3856 }
3857
3858
3859 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3860 PyObject *resultobj;
3861 wxSize *arg1 = (wxSize *) 0 ;
3862 bool result;
3863 PyObject * obj0 = 0 ;
3864 char *kwnames[] = {
3865 (char *) "self", NULL
3866 };
3867
3868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3870 if (SWIG_arg_fail(1)) SWIG_fail;
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 {
3879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3880 }
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxSize *arg1 = (wxSize *) 0 ;
3890 wxSize *arg2 = 0 ;
3891 wxSize temp2 ;
3892 PyObject * obj0 = 0 ;
3893 PyObject * obj1 = 0 ;
3894 char *kwnames[] = {
3895 (char *) "self",(char *) "size", NULL
3896 };
3897
3898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3900 if (SWIG_arg_fail(1)) SWIG_fail;
3901 {
3902 arg2 = &temp2;
3903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3904 }
3905 {
3906 PyThreadState* __tstate = wxPyBeginAllowThreads();
3907 (arg1)->SetDefaults((wxSize const &)*arg2);
3908
3909 wxPyEndAllowThreads(__tstate);
3910 if (PyErr_Occurred()) SWIG_fail;
3911 }
3912 Py_INCREF(Py_None); resultobj = Py_None;
3913 return resultobj;
3914 fail:
3915 return NULL;
3916 }
3917
3918
3919 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3920 PyObject *resultobj;
3921 wxSize *arg1 = (wxSize *) 0 ;
3922 PyObject *result;
3923 PyObject * obj0 = 0 ;
3924 char *kwnames[] = {
3925 (char *) "self", NULL
3926 };
3927
3928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3930 if (SWIG_arg_fail(1)) SWIG_fail;
3931 {
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 result = (PyObject *)wxSize_Get(arg1);
3934
3935 wxPyEndAllowThreads(__tstate);
3936 if (PyErr_Occurred()) SWIG_fail;
3937 }
3938 resultobj = result;
3939 return resultobj;
3940 fail:
3941 return NULL;
3942 }
3943
3944
3945 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3946 PyObject *obj;
3947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3948 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3949 Py_INCREF(obj);
3950 return Py_BuildValue((char *)"");
3951 }
3952 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3955 double arg2 ;
3956 PyObject * obj0 = 0 ;
3957 PyObject * obj1 = 0 ;
3958 char *kwnames[] = {
3959 (char *) "self",(char *) "x", NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3964 if (SWIG_arg_fail(1)) SWIG_fail;
3965 {
3966 arg2 = (double)(SWIG_As_double(obj1));
3967 if (SWIG_arg_fail(2)) SWIG_fail;
3968 }
3969 if (arg1) (arg1)->x = arg2;
3970
3971 Py_INCREF(Py_None); resultobj = Py_None;
3972 return resultobj;
3973 fail:
3974 return NULL;
3975 }
3976
3977
3978 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj;
3980 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3981 double result;
3982 PyObject * obj0 = 0 ;
3983 char *kwnames[] = {
3984 (char *) "self", NULL
3985 };
3986
3987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3989 if (SWIG_arg_fail(1)) SWIG_fail;
3990 result = (double) ((arg1)->x);
3991
3992 {
3993 resultobj = SWIG_From_double((double)(result));
3994 }
3995 return resultobj;
3996 fail:
3997 return NULL;
3998 }
3999
4000
4001 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4002 PyObject *resultobj;
4003 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4004 double arg2 ;
4005 PyObject * obj0 = 0 ;
4006 PyObject * obj1 = 0 ;
4007 char *kwnames[] = {
4008 (char *) "self",(char *) "y", NULL
4009 };
4010
4011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4013 if (SWIG_arg_fail(1)) SWIG_fail;
4014 {
4015 arg2 = (double)(SWIG_As_double(obj1));
4016 if (SWIG_arg_fail(2)) SWIG_fail;
4017 }
4018 if (arg1) (arg1)->y = arg2;
4019
4020 Py_INCREF(Py_None); resultobj = Py_None;
4021 return resultobj;
4022 fail:
4023 return NULL;
4024 }
4025
4026
4027 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4028 PyObject *resultobj;
4029 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4030 double result;
4031 PyObject * obj0 = 0 ;
4032 char *kwnames[] = {
4033 (char *) "self", NULL
4034 };
4035
4036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4038 if (SWIG_arg_fail(1)) SWIG_fail;
4039 result = (double) ((arg1)->y);
4040
4041 {
4042 resultobj = SWIG_From_double((double)(result));
4043 }
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 double arg1 = (double) 0.0 ;
4053 double arg2 = (double) 0.0 ;
4054 wxRealPoint *result;
4055 PyObject * obj0 = 0 ;
4056 PyObject * obj1 = 0 ;
4057 char *kwnames[] = {
4058 (char *) "x",(char *) "y", NULL
4059 };
4060
4061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4062 if (obj0) {
4063 {
4064 arg1 = (double)(SWIG_As_double(obj0));
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 }
4067 }
4068 if (obj1) {
4069 {
4070 arg2 = (double)(SWIG_As_double(obj1));
4071 if (SWIG_arg_fail(2)) SWIG_fail;
4072 }
4073 }
4074 {
4075 PyThreadState* __tstate = wxPyBeginAllowThreads();
4076 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4077
4078 wxPyEndAllowThreads(__tstate);
4079 if (PyErr_Occurred()) SWIG_fail;
4080 }
4081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4082 return resultobj;
4083 fail:
4084 return NULL;
4085 }
4086
4087
4088 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4089 PyObject *resultobj;
4090 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4091 PyObject * obj0 = 0 ;
4092 char *kwnames[] = {
4093 (char *) "self", NULL
4094 };
4095
4096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4098 if (SWIG_arg_fail(1)) SWIG_fail;
4099 {
4100 PyThreadState* __tstate = wxPyBeginAllowThreads();
4101 delete arg1;
4102
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 Py_INCREF(Py_None); resultobj = Py_None;
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4116 wxRealPoint *arg2 = 0 ;
4117 bool result;
4118 wxRealPoint temp2 ;
4119 PyObject * obj0 = 0 ;
4120 PyObject * obj1 = 0 ;
4121 char *kwnames[] = {
4122 (char *) "self",(char *) "pt", NULL
4123 };
4124
4125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4127 if (SWIG_arg_fail(1)) SWIG_fail;
4128 {
4129 arg2 = &temp2;
4130 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4131 }
4132 {
4133 PyThreadState* __tstate = wxPyBeginAllowThreads();
4134 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4135
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 {
4140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4141 }
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj;
4150 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4151 wxRealPoint *arg2 = 0 ;
4152 bool result;
4153 wxRealPoint temp2 ;
4154 PyObject * obj0 = 0 ;
4155 PyObject * obj1 = 0 ;
4156 char *kwnames[] = {
4157 (char *) "self",(char *) "pt", NULL
4158 };
4159
4160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4162 if (SWIG_arg_fail(1)) SWIG_fail;
4163 {
4164 arg2 = &temp2;
4165 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 {
4175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4176 }
4177 return resultobj;
4178 fail:
4179 return NULL;
4180 }
4181
4182
4183 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4184 PyObject *resultobj;
4185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4186 wxRealPoint *arg2 = 0 ;
4187 wxRealPoint result;
4188 wxRealPoint temp2 ;
4189 PyObject * obj0 = 0 ;
4190 PyObject * obj1 = 0 ;
4191 char *kwnames[] = {
4192 (char *) "self",(char *) "pt", NULL
4193 };
4194
4195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4197 if (SWIG_arg_fail(1)) SWIG_fail;
4198 {
4199 arg2 = &temp2;
4200 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4201 }
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4205
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 {
4210 wxRealPoint * resultptr;
4211 resultptr = new wxRealPoint((wxRealPoint &)(result));
4212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4213 }
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj;
4222 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4223 wxRealPoint *arg2 = 0 ;
4224 wxRealPoint result;
4225 wxRealPoint temp2 ;
4226 PyObject * obj0 = 0 ;
4227 PyObject * obj1 = 0 ;
4228 char *kwnames[] = {
4229 (char *) "self",(char *) "pt", NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4234 if (SWIG_arg_fail(1)) SWIG_fail;
4235 {
4236 arg2 = &temp2;
4237 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4238 }
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4242
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 {
4247 wxRealPoint * resultptr;
4248 resultptr = new wxRealPoint((wxRealPoint &)(result));
4249 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4250 }
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj;
4259 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4260 double arg2 ;
4261 double arg3 ;
4262 PyObject * obj0 = 0 ;
4263 PyObject * obj1 = 0 ;
4264 PyObject * obj2 = 0 ;
4265 char *kwnames[] = {
4266 (char *) "self",(char *) "x",(char *) "y", NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4271 if (SWIG_arg_fail(1)) SWIG_fail;
4272 {
4273 arg2 = (double)(SWIG_As_double(obj1));
4274 if (SWIG_arg_fail(2)) SWIG_fail;
4275 }
4276 {
4277 arg3 = (double)(SWIG_As_double(obj2));
4278 if (SWIG_arg_fail(3)) SWIG_fail;
4279 }
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 wxRealPoint_Set(arg1,arg2,arg3);
4283
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 Py_INCREF(Py_None); resultobj = Py_None;
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4297 PyObject *result;
4298 PyObject * obj0 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "self", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4305 if (SWIG_arg_fail(1)) SWIG_fail;
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 result = (PyObject *)wxRealPoint_Get(arg1);
4309
4310 wxPyEndAllowThreads(__tstate);
4311 if (PyErr_Occurred()) SWIG_fail;
4312 }
4313 resultobj = result;
4314 return resultobj;
4315 fail:
4316 return NULL;
4317 }
4318
4319
4320 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4321 PyObject *obj;
4322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4323 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4324 Py_INCREF(obj);
4325 return Py_BuildValue((char *)"");
4326 }
4327 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxPoint *arg1 = (wxPoint *) 0 ;
4330 int arg2 ;
4331 PyObject * obj0 = 0 ;
4332 PyObject * obj1 = 0 ;
4333 char *kwnames[] = {
4334 (char *) "self",(char *) "x", NULL
4335 };
4336
4337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4339 if (SWIG_arg_fail(1)) SWIG_fail;
4340 {
4341 arg2 = (int)(SWIG_As_int(obj1));
4342 if (SWIG_arg_fail(2)) SWIG_fail;
4343 }
4344 if (arg1) (arg1)->x = arg2;
4345
4346 Py_INCREF(Py_None); resultobj = Py_None;
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4354 PyObject *resultobj;
4355 wxPoint *arg1 = (wxPoint *) 0 ;
4356 int result;
4357 PyObject * obj0 = 0 ;
4358 char *kwnames[] = {
4359 (char *) "self", NULL
4360 };
4361
4362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4364 if (SWIG_arg_fail(1)) SWIG_fail;
4365 result = (int) ((arg1)->x);
4366
4367 {
4368 resultobj = SWIG_From_int((int)(result));
4369 }
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj;
4378 wxPoint *arg1 = (wxPoint *) 0 ;
4379 int arg2 ;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4382 char *kwnames[] = {
4383 (char *) "self",(char *) "y", NULL
4384 };
4385
4386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4388 if (SWIG_arg_fail(1)) SWIG_fail;
4389 {
4390 arg2 = (int)(SWIG_As_int(obj1));
4391 if (SWIG_arg_fail(2)) SWIG_fail;
4392 }
4393 if (arg1) (arg1)->y = arg2;
4394
4395 Py_INCREF(Py_None); resultobj = Py_None;
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj;
4404 wxPoint *arg1 = (wxPoint *) 0 ;
4405 int result;
4406 PyObject * obj0 = 0 ;
4407 char *kwnames[] = {
4408 (char *) "self", NULL
4409 };
4410
4411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4413 if (SWIG_arg_fail(1)) SWIG_fail;
4414 result = (int) ((arg1)->y);
4415
4416 {
4417 resultobj = SWIG_From_int((int)(result));
4418 }
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 int arg1 = (int) 0 ;
4428 int arg2 = (int) 0 ;
4429 wxPoint *result;
4430 PyObject * obj0 = 0 ;
4431 PyObject * obj1 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "x",(char *) "y", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4437 if (obj0) {
4438 {
4439 arg1 = (int)(SWIG_As_int(obj0));
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 }
4442 }
4443 if (obj1) {
4444 {
4445 arg2 = (int)(SWIG_As_int(obj1));
4446 if (SWIG_arg_fail(2)) SWIG_fail;
4447 }
4448 }
4449 {
4450 PyThreadState* __tstate = wxPyBeginAllowThreads();
4451 result = (wxPoint *)new wxPoint(arg1,arg2);
4452
4453 wxPyEndAllowThreads(__tstate);
4454 if (PyErr_Occurred()) SWIG_fail;
4455 }
4456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4457 return resultobj;
4458 fail:
4459 return NULL;
4460 }
4461
4462
4463 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4464 PyObject *resultobj;
4465 wxPoint *arg1 = (wxPoint *) 0 ;
4466 PyObject * obj0 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 delete arg1;
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 Py_INCREF(Py_None); resultobj = Py_None;
4482 return resultobj;
4483 fail:
4484 return NULL;
4485 }
4486
4487
4488 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4489 PyObject *resultobj;
4490 wxPoint *arg1 = (wxPoint *) 0 ;
4491 wxPoint *arg2 = 0 ;
4492 bool result;
4493 wxPoint temp2 ;
4494 PyObject * obj0 = 0 ;
4495 PyObject * obj1 = 0 ;
4496 char *kwnames[] = {
4497 (char *) "self",(char *) "pt", NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4502 if (SWIG_arg_fail(1)) SWIG_fail;
4503 {
4504 arg2 = &temp2;
4505 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4506 }
4507 {
4508 PyThreadState* __tstate = wxPyBeginAllowThreads();
4509 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4510
4511 wxPyEndAllowThreads(__tstate);
4512 if (PyErr_Occurred()) SWIG_fail;
4513 }
4514 {
4515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4516 }
4517 return resultobj;
4518 fail:
4519 return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4524 PyObject *resultobj;
4525 wxPoint *arg1 = (wxPoint *) 0 ;
4526 wxPoint *arg2 = 0 ;
4527 bool result;
4528 wxPoint temp2 ;
4529 PyObject * obj0 = 0 ;
4530 PyObject * obj1 = 0 ;
4531 char *kwnames[] = {
4532 (char *) "self",(char *) "pt", NULL
4533 };
4534
4535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4537 if (SWIG_arg_fail(1)) SWIG_fail;
4538 {
4539 arg2 = &temp2;
4540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4541 }
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4545
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4551 }
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4559 PyObject *resultobj;
4560 wxPoint *arg1 = (wxPoint *) 0 ;
4561 wxPoint *arg2 = 0 ;
4562 wxPoint result;
4563 wxPoint temp2 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char *kwnames[] = {
4567 (char *) "self",(char *) "pt", NULL
4568 };
4569
4570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4572 if (SWIG_arg_fail(1)) SWIG_fail;
4573 {
4574 arg2 = &temp2;
4575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (arg1)->operator +((wxPoint const &)*arg2);
4580
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 {
4585 wxPoint * resultptr;
4586 resultptr = new wxPoint((wxPoint &)(result));
4587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4588 }
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4596 PyObject *resultobj;
4597 wxPoint *arg1 = (wxPoint *) 0 ;
4598 wxPoint *arg2 = 0 ;
4599 wxPoint result;
4600 wxPoint temp2 ;
4601 PyObject * obj0 = 0 ;
4602 PyObject * obj1 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "self",(char *) "pt", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4609 if (SWIG_arg_fail(1)) SWIG_fail;
4610 {
4611 arg2 = &temp2;
4612 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4613 }
4614 {
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 result = (arg1)->operator -((wxPoint const &)*arg2);
4617
4618 wxPyEndAllowThreads(__tstate);
4619 if (PyErr_Occurred()) SWIG_fail;
4620 }
4621 {
4622 wxPoint * resultptr;
4623 resultptr = new wxPoint((wxPoint &)(result));
4624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4625 }
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj;
4634 wxPoint *arg1 = (wxPoint *) 0 ;
4635 wxPoint *arg2 = 0 ;
4636 wxPoint *result;
4637 wxPoint temp2 ;
4638 PyObject * obj0 = 0 ;
4639 PyObject * obj1 = 0 ;
4640 char *kwnames[] = {
4641 (char *) "self",(char *) "pt", NULL
4642 };
4643
4644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4646 if (SWIG_arg_fail(1)) SWIG_fail;
4647 {
4648 arg2 = &temp2;
4649 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4650 }
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 {
4654 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4655 result = (wxPoint *) &_result_ref;
4656 }
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj;
4670 wxPoint *arg1 = (wxPoint *) 0 ;
4671 wxPoint *arg2 = 0 ;
4672 wxPoint *result;
4673 wxPoint temp2 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 char *kwnames[] = {
4677 (char *) "self",(char *) "pt", NULL
4678 };
4679
4680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4682 if (SWIG_arg_fail(1)) SWIG_fail;
4683 {
4684 arg2 = &temp2;
4685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4686 }
4687 {
4688 PyThreadState* __tstate = wxPyBeginAllowThreads();
4689 {
4690 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4691 result = (wxPoint *) &_result_ref;
4692 }
4693
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj;
4706 wxPoint *arg1 = (wxPoint *) 0 ;
4707 long arg2 ;
4708 long arg3 ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self",(char *) "x",(char *) "y", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 arg2 = (long)(SWIG_As_long(obj1));
4721 if (SWIG_arg_fail(2)) SWIG_fail;
4722 }
4723 {
4724 arg3 = (long)(SWIG_As_long(obj2));
4725 if (SWIG_arg_fail(3)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 wxPoint_Set(arg1,arg2,arg3);
4730
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 Py_INCREF(Py_None); resultobj = Py_None;
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj;
4743 wxPoint *arg1 = (wxPoint *) 0 ;
4744 PyObject *result;
4745 PyObject * obj0 = 0 ;
4746 char *kwnames[] = {
4747 (char *) "self", NULL
4748 };
4749
4750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4752 if (SWIG_arg_fail(1)) SWIG_fail;
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (PyObject *)wxPoint_Get(arg1);
4756
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 resultobj = result;
4761 return resultobj;
4762 fail:
4763 return NULL;
4764 }
4765
4766
4767 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4768 PyObject *obj;
4769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4770 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4771 Py_INCREF(obj);
4772 return Py_BuildValue((char *)"");
4773 }
4774 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj;
4776 int arg1 = (int) 0 ;
4777 int arg2 = (int) 0 ;
4778 int arg3 = (int) 0 ;
4779 int arg4 = (int) 0 ;
4780 wxRect *result;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 PyObject * obj2 = 0 ;
4784 PyObject * obj3 = 0 ;
4785 char *kwnames[] = {
4786 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4787 };
4788
4789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4790 if (obj0) {
4791 {
4792 arg1 = (int)(SWIG_As_int(obj0));
4793 if (SWIG_arg_fail(1)) SWIG_fail;
4794 }
4795 }
4796 if (obj1) {
4797 {
4798 arg2 = (int)(SWIG_As_int(obj1));
4799 if (SWIG_arg_fail(2)) SWIG_fail;
4800 }
4801 }
4802 if (obj2) {
4803 {
4804 arg3 = (int)(SWIG_As_int(obj2));
4805 if (SWIG_arg_fail(3)) SWIG_fail;
4806 }
4807 }
4808 if (obj3) {
4809 {
4810 arg4 = (int)(SWIG_As_int(obj3));
4811 if (SWIG_arg_fail(4)) SWIG_fail;
4812 }
4813 }
4814 {
4815 PyThreadState* __tstate = wxPyBeginAllowThreads();
4816 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4817
4818 wxPyEndAllowThreads(__tstate);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4829 PyObject *resultobj;
4830 wxPoint *arg1 = 0 ;
4831 wxPoint *arg2 = 0 ;
4832 wxRect *result;
4833 wxPoint temp1 ;
4834 wxPoint temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char *kwnames[] = {
4838 (char *) "topLeft",(char *) "bottomRight", NULL
4839 };
4840
4841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4842 {
4843 arg1 = &temp1;
4844 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4845 }
4846 {
4847 arg2 = &temp2;
4848 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4849 }
4850 {
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4853
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj;
4866 wxPoint *arg1 = 0 ;
4867 wxSize *arg2 = 0 ;
4868 wxRect *result;
4869 wxPoint temp1 ;
4870 wxSize temp2 ;
4871 PyObject * obj0 = 0 ;
4872 PyObject * obj1 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "pos",(char *) "size", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4878 {
4879 arg1 = &temp1;
4880 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4881 }
4882 {
4883 arg2 = &temp2;
4884 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4885 }
4886 {
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4894 return resultobj;
4895 fail:
4896 return NULL;
4897 }
4898
4899
4900 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4901 PyObject *resultobj;
4902 wxSize *arg1 = 0 ;
4903 wxRect *result;
4904 wxSize temp1 ;
4905 PyObject * obj0 = 0 ;
4906 char *kwnames[] = {
4907 (char *) "size", NULL
4908 };
4909
4910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4911 {
4912 arg1 = &temp1;
4913 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4918
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj;
4931 wxRect *arg1 = (wxRect *) 0 ;
4932 PyObject * obj0 = 0 ;
4933 char *kwnames[] = {
4934 (char *) "self", NULL
4935 };
4936
4937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4939 if (SWIG_arg_fail(1)) SWIG_fail;
4940 {
4941 PyThreadState* __tstate = wxPyBeginAllowThreads();
4942 delete arg1;
4943
4944 wxPyEndAllowThreads(__tstate);
4945 if (PyErr_Occurred()) SWIG_fail;
4946 }
4947 Py_INCREF(Py_None); resultobj = Py_None;
4948 return resultobj;
4949 fail:
4950 return NULL;
4951 }
4952
4953
4954 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4955 PyObject *resultobj;
4956 wxRect *arg1 = (wxRect *) 0 ;
4957 int result;
4958 PyObject * obj0 = 0 ;
4959 char *kwnames[] = {
4960 (char *) "self", NULL
4961 };
4962
4963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4965 if (SWIG_arg_fail(1)) SWIG_fail;
4966 {
4967 PyThreadState* __tstate = wxPyBeginAllowThreads();
4968 result = (int)((wxRect const *)arg1)->GetX();
4969
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 {
4974 resultobj = SWIG_From_int((int)(result));
4975 }
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj;
4984 wxRect *arg1 = (wxRect *) 0 ;
4985 int arg2 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 char *kwnames[] = {
4989 (char *) "self",(char *) "x", NULL
4990 };
4991
4992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4994 if (SWIG_arg_fail(1)) SWIG_fail;
4995 {
4996 arg2 = (int)(SWIG_As_int(obj1));
4997 if (SWIG_arg_fail(2)) SWIG_fail;
4998 }
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 (arg1)->SetX(arg2);
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 Py_INCREF(Py_None); resultobj = Py_None;
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj;
5015 wxRect *arg1 = (wxRect *) 0 ;
5016 int result;
5017 PyObject * obj0 = 0 ;
5018 char *kwnames[] = {
5019 (char *) "self", NULL
5020 };
5021
5022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5024 if (SWIG_arg_fail(1)) SWIG_fail;
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = (int)(arg1)->GetY();
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = SWIG_From_int((int)(result));
5034 }
5035 return resultobj;
5036 fail:
5037 return NULL;
5038 }
5039
5040
5041 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5042 PyObject *resultobj;
5043 wxRect *arg1 = (wxRect *) 0 ;
5044 int arg2 ;
5045 PyObject * obj0 = 0 ;
5046 PyObject * obj1 = 0 ;
5047 char *kwnames[] = {
5048 (char *) "self",(char *) "y", NULL
5049 };
5050
5051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5053 if (SWIG_arg_fail(1)) SWIG_fail;
5054 {
5055 arg2 = (int)(SWIG_As_int(obj1));
5056 if (SWIG_arg_fail(2)) SWIG_fail;
5057 }
5058 {
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 (arg1)->SetY(arg2);
5061
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 Py_INCREF(Py_None); resultobj = Py_None;
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj;
5074 wxRect *arg1 = (wxRect *) 0 ;
5075 int result;
5076 PyObject * obj0 = 0 ;
5077 char *kwnames[] = {
5078 (char *) "self", NULL
5079 };
5080
5081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5083 if (SWIG_arg_fail(1)) SWIG_fail;
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (int)((wxRect const *)arg1)->GetWidth();
5087
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 {
5092 resultobj = SWIG_From_int((int)(result));
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5101 PyObject *resultobj;
5102 wxRect *arg1 = (wxRect *) 0 ;
5103 int arg2 ;
5104 PyObject * obj0 = 0 ;
5105 PyObject * obj1 = 0 ;
5106 char *kwnames[] = {
5107 (char *) "self",(char *) "w", NULL
5108 };
5109
5110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5112 if (SWIG_arg_fail(1)) SWIG_fail;
5113 {
5114 arg2 = (int)(SWIG_As_int(obj1));
5115 if (SWIG_arg_fail(2)) SWIG_fail;
5116 }
5117 {
5118 PyThreadState* __tstate = wxPyBeginAllowThreads();
5119 (arg1)->SetWidth(arg2);
5120
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 Py_INCREF(Py_None); resultobj = Py_None;
5125 return resultobj;
5126 fail:
5127 return NULL;
5128 }
5129
5130
5131 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj;
5133 wxRect *arg1 = (wxRect *) 0 ;
5134 int result;
5135 PyObject * obj0 = 0 ;
5136 char *kwnames[] = {
5137 (char *) "self", NULL
5138 };
5139
5140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5142 if (SWIG_arg_fail(1)) SWIG_fail;
5143 {
5144 PyThreadState* __tstate = wxPyBeginAllowThreads();
5145 result = (int)((wxRect const *)arg1)->GetHeight();
5146
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 {
5151 resultobj = SWIG_From_int((int)(result));
5152 }
5153 return resultobj;
5154 fail:
5155 return NULL;
5156 }
5157
5158
5159 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5160 PyObject *resultobj;
5161 wxRect *arg1 = (wxRect *) 0 ;
5162 int arg2 ;
5163 PyObject * obj0 = 0 ;
5164 PyObject * obj1 = 0 ;
5165 char *kwnames[] = {
5166 (char *) "self",(char *) "h", NULL
5167 };
5168
5169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5171 if (SWIG_arg_fail(1)) SWIG_fail;
5172 {
5173 arg2 = (int)(SWIG_As_int(obj1));
5174 if (SWIG_arg_fail(2)) SWIG_fail;
5175 }
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 (arg1)->SetHeight(arg2);
5179
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 Py_INCREF(Py_None); resultobj = Py_None;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5191 PyObject *resultobj;
5192 wxRect *arg1 = (wxRect *) 0 ;
5193 wxPoint result;
5194 PyObject * obj0 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5201 if (SWIG_arg_fail(1)) SWIG_fail;
5202 {
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = ((wxRect const *)arg1)->GetPosition();
5205
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 {
5210 wxPoint * resultptr;
5211 resultptr = new wxPoint((wxPoint &)(result));
5212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5213 }
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 wxPoint *arg2 = 0 ;
5224 wxPoint temp2 ;
5225 PyObject * obj0 = 0 ;
5226 PyObject * obj1 = 0 ;
5227 char *kwnames[] = {
5228 (char *) "self",(char *) "p", NULL
5229 };
5230
5231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5233 if (SWIG_arg_fail(1)) SWIG_fail;
5234 {
5235 arg2 = &temp2;
5236 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5237 }
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 (arg1)->SetPosition((wxPoint const &)*arg2);
5241
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 Py_INCREF(Py_None); resultobj = Py_None;
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj;
5254 wxRect *arg1 = (wxRect *) 0 ;
5255 wxSize result;
5256 PyObject * obj0 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 {
5265 PyThreadState* __tstate = wxPyBeginAllowThreads();
5266 result = ((wxRect const *)arg1)->GetSize();
5267
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 {
5272 wxSize * resultptr;
5273 resultptr = new wxSize((wxSize &)(result));
5274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5275 }
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxRect *arg1 = (wxRect *) 0 ;
5285 wxSize *arg2 = 0 ;
5286 wxSize temp2 ;
5287 PyObject * obj0 = 0 ;
5288 PyObject * obj1 = 0 ;
5289 char *kwnames[] = {
5290 (char *) "self",(char *) "s", NULL
5291 };
5292
5293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5295 if (SWIG_arg_fail(1)) SWIG_fail;
5296 {
5297 arg2 = &temp2;
5298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5299 }
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 (arg1)->SetSize((wxSize const &)*arg2);
5303
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 Py_INCREF(Py_None); resultobj = Py_None;
5308 return resultobj;
5309 fail:
5310 return NULL;
5311 }
5312
5313
5314 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5315 PyObject *resultobj;
5316 wxRect *arg1 = (wxRect *) 0 ;
5317 bool result;
5318 PyObject * obj0 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "self", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(1)) SWIG_fail;
5326 {
5327 PyThreadState* __tstate = wxPyBeginAllowThreads();
5328 result = (bool)((wxRect const *)arg1)->IsEmpty();
5329
5330 wxPyEndAllowThreads(__tstate);
5331 if (PyErr_Occurred()) SWIG_fail;
5332 }
5333 {
5334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5335 }
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj;
5344 wxRect *arg1 = (wxRect *) 0 ;
5345 wxPoint result;
5346 PyObject * obj0 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = ((wxRect const *)arg1)->GetTopLeft();
5357
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 wxPoint * resultptr;
5363 resultptr = new wxPoint((wxPoint &)(result));
5364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint *arg2 = 0 ;
5376 wxPoint temp2 ;
5377 PyObject * obj0 = 0 ;
5378 PyObject * obj1 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "self",(char *) "p", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5385 if (SWIG_arg_fail(1)) SWIG_fail;
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5393
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 Py_INCREF(Py_None); resultobj = Py_None;
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxRect *arg1 = (wxRect *) 0 ;
5407 wxPoint result;
5408 PyObject * obj0 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(1)) SWIG_fail;
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 result = ((wxRect const *)arg1)->GetBottomRight();
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 wxPoint * resultptr;
5425 resultptr = new wxPoint((wxPoint &)(result));
5426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5427 }
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj;
5436 wxRect *arg1 = (wxRect *) 0 ;
5437 wxPoint *arg2 = 0 ;
5438 wxPoint temp2 ;
5439 PyObject * obj0 = 0 ;
5440 PyObject * obj1 = 0 ;
5441 char *kwnames[] = {
5442 (char *) "self",(char *) "p", NULL
5443 };
5444
5445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5447 if (SWIG_arg_fail(1)) SWIG_fail;
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5455
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 Py_INCREF(Py_None); resultobj = Py_None;
5460 return resultobj;
5461 fail:
5462 return NULL;
5463 }
5464
5465
5466 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5467 PyObject *resultobj;
5468 wxRect *arg1 = (wxRect *) 0 ;
5469 int result;
5470 PyObject * obj0 = 0 ;
5471 char *kwnames[] = {
5472 (char *) "self", NULL
5473 };
5474
5475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5477 if (SWIG_arg_fail(1)) SWIG_fail;
5478 {
5479 PyThreadState* __tstate = wxPyBeginAllowThreads();
5480 result = (int)((wxRect const *)arg1)->GetLeft();
5481
5482 wxPyEndAllowThreads(__tstate);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 {
5486 resultobj = SWIG_From_int((int)(result));
5487 }
5488 return resultobj;
5489 fail:
5490 return NULL;
5491 }
5492
5493
5494 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5495 PyObject *resultobj;
5496 wxRect *arg1 = (wxRect *) 0 ;
5497 int result;
5498 PyObject * obj0 = 0 ;
5499 char *kwnames[] = {
5500 (char *) "self", NULL
5501 };
5502
5503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5505 if (SWIG_arg_fail(1)) SWIG_fail;
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 result = (int)((wxRect const *)arg1)->GetTop();
5509
5510 wxPyEndAllowThreads(__tstate);
5511 if (PyErr_Occurred()) SWIG_fail;
5512 }
5513 {
5514 resultobj = SWIG_From_int((int)(result));
5515 }
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj;
5524 wxRect *arg1 = (wxRect *) 0 ;
5525 int result;
5526 PyObject * obj0 = 0 ;
5527 char *kwnames[] = {
5528 (char *) "self", NULL
5529 };
5530
5531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5533 if (SWIG_arg_fail(1)) SWIG_fail;
5534 {
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 result = (int)((wxRect const *)arg1)->GetBottom();
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = SWIG_From_int((int)(result));
5543 }
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5551 PyObject *resultobj;
5552 wxRect *arg1 = (wxRect *) 0 ;
5553 int result;
5554 PyObject * obj0 = 0 ;
5555 char *kwnames[] = {
5556 (char *) "self", NULL
5557 };
5558
5559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5561 if (SWIG_arg_fail(1)) SWIG_fail;
5562 {
5563 PyThreadState* __tstate = wxPyBeginAllowThreads();
5564 result = (int)((wxRect const *)arg1)->GetRight();
5565
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 {
5570 resultobj = SWIG_From_int((int)(result));
5571 }
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5579 PyObject *resultobj;
5580 wxRect *arg1 = (wxRect *) 0 ;
5581 int arg2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char *kwnames[] = {
5585 (char *) "self",(char *) "left", NULL
5586 };
5587
5588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5590 if (SWIG_arg_fail(1)) SWIG_fail;
5591 {
5592 arg2 = (int)(SWIG_As_int(obj1));
5593 if (SWIG_arg_fail(2)) SWIG_fail;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetLeft(arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 wxRect *arg1 = (wxRect *) 0 ;
5612 int arg2 ;
5613 PyObject * obj0 = 0 ;
5614 PyObject * obj1 = 0 ;
5615 char *kwnames[] = {
5616 (char *) "self",(char *) "right", NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5621 if (SWIG_arg_fail(1)) SWIG_fail;
5622 {
5623 arg2 = (int)(SWIG_As_int(obj1));
5624 if (SWIG_arg_fail(2)) SWIG_fail;
5625 }
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 (arg1)->SetRight(arg2);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 Py_INCREF(Py_None); resultobj = Py_None;
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 wxRect *arg1 = (wxRect *) 0 ;
5643 int arg2 ;
5644 PyObject * obj0 = 0 ;
5645 PyObject * obj1 = 0 ;
5646 char *kwnames[] = {
5647 (char *) "self",(char *) "top", NULL
5648 };
5649
5650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5652 if (SWIG_arg_fail(1)) SWIG_fail;
5653 {
5654 arg2 = (int)(SWIG_As_int(obj1));
5655 if (SWIG_arg_fail(2)) SWIG_fail;
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 (arg1)->SetTop(arg2);
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 Py_INCREF(Py_None); resultobj = Py_None;
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxRect *arg1 = (wxRect *) 0 ;
5674 int arg2 ;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 char *kwnames[] = {
5678 (char *) "self",(char *) "bottom", NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5683 if (SWIG_arg_fail(1)) SWIG_fail;
5684 {
5685 arg2 = (int)(SWIG_As_int(obj1));
5686 if (SWIG_arg_fail(2)) SWIG_fail;
5687 }
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 (arg1)->SetBottom(arg2);
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 Py_INCREF(Py_None); resultobj = Py_None;
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5703 PyObject *resultobj;
5704 wxRect *arg1 = (wxRect *) 0 ;
5705 int arg2 ;
5706 int arg3 ;
5707 wxRect *result;
5708 PyObject * obj0 = 0 ;
5709 PyObject * obj1 = 0 ;
5710 PyObject * obj2 = 0 ;
5711 char *kwnames[] = {
5712 (char *) "self",(char *) "dx",(char *) "dy", NULL
5713 };
5714
5715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5717 if (SWIG_arg_fail(1)) SWIG_fail;
5718 {
5719 arg2 = (int)(SWIG_As_int(obj1));
5720 if (SWIG_arg_fail(2)) SWIG_fail;
5721 }
5722 {
5723 arg3 = (int)(SWIG_As_int(obj2));
5724 if (SWIG_arg_fail(3)) SWIG_fail;
5725 }
5726 {
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 {
5729 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5730 result = (wxRect *) &_result_ref;
5731 }
5732
5733 wxPyEndAllowThreads(__tstate);
5734 if (PyErr_Occurred()) SWIG_fail;
5735 }
5736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj;
5745 wxRect *arg1 = (wxRect *) 0 ;
5746 int arg2 ;
5747 int arg3 ;
5748 wxRect *result;
5749 PyObject * obj0 = 0 ;
5750 PyObject * obj1 = 0 ;
5751 PyObject * obj2 = 0 ;
5752 char *kwnames[] = {
5753 (char *) "self",(char *) "dx",(char *) "dy", NULL
5754 };
5755
5756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5758 if (SWIG_arg_fail(1)) SWIG_fail;
5759 {
5760 arg2 = (int)(SWIG_As_int(obj1));
5761 if (SWIG_arg_fail(2)) SWIG_fail;
5762 }
5763 {
5764 arg3 = (int)(SWIG_As_int(obj2));
5765 if (SWIG_arg_fail(3)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 {
5770 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5771 result = (wxRect *) &_result_ref;
5772 }
5773
5774 wxPyEndAllowThreads(__tstate);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj;
5786 wxRect *arg1 = (wxRect *) 0 ;
5787 int arg2 ;
5788 int arg3 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 char *kwnames[] = {
5793 (char *) "self",(char *) "dx",(char *) "dy", NULL
5794 };
5795
5796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5798 if (SWIG_arg_fail(1)) SWIG_fail;
5799 {
5800 arg2 = (int)(SWIG_As_int(obj1));
5801 if (SWIG_arg_fail(2)) SWIG_fail;
5802 }
5803 {
5804 arg3 = (int)(SWIG_As_int(obj2));
5805 if (SWIG_arg_fail(3)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 (arg1)->Offset(arg2,arg3);
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 Py_INCREF(Py_None); resultobj = Py_None;
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 wxPoint *arg2 = 0 ;
5825 wxPoint temp2 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "self",(char *) "pt", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(1)) SWIG_fail;
5835 {
5836 arg2 = &temp2;
5837 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5838 }
5839 {
5840 PyThreadState* __tstate = wxPyBeginAllowThreads();
5841 (arg1)->Offset((wxPoint const &)*arg2);
5842
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 Py_INCREF(Py_None); resultobj = Py_None;
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxRect *arg1 = (wxRect *) 0 ;
5856 wxRect *arg2 = 0 ;
5857 wxRect result;
5858 wxRect temp2 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "rect", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = (arg1)->Intersect((wxRect const &)*arg2);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 wxRect * resultptr;
5881 resultptr = new wxRect((wxRect &)(result));
5882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5883 }
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj;
5892 wxRect *arg1 = (wxRect *) 0 ;
5893 wxRect *arg2 = 0 ;
5894 wxRect result;
5895 wxRect temp2 ;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "self",(char *) "rect", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5904 if (SWIG_arg_fail(1)) SWIG_fail;
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = (arg1)->Union((wxRect const &)*arg2);
5912
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 {
5917 wxRect * resultptr;
5918 resultptr = new wxRect((wxRect &)(result));
5919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj;
5929 wxRect *arg1 = (wxRect *) 0 ;
5930 wxRect *arg2 = 0 ;
5931 wxRect result;
5932 wxRect temp2 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 char *kwnames[] = {
5936 (char *) "self",(char *) "rect", NULL
5937 };
5938
5939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5941 if (SWIG_arg_fail(1)) SWIG_fail;
5942 {
5943 arg2 = &temp2;
5944 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5945 }
5946 {
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 {
5954 wxRect * resultptr;
5955 resultptr = new wxRect((wxRect &)(result));
5956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5957 }
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj;
5966 wxRect *arg1 = (wxRect *) 0 ;
5967 wxRect *arg2 = 0 ;
5968 wxRect *result;
5969 wxRect temp2 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 char *kwnames[] = {
5973 (char *) "self",(char *) "rect", NULL
5974 };
5975
5976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5978 if (SWIG_arg_fail(1)) SWIG_fail;
5979 {
5980 arg2 = &temp2;
5981 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5982 }
5983 {
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 {
5986 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5987 result = (wxRect *) &_result_ref;
5988 }
5989
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj;
6002 wxRect *arg1 = (wxRect *) 0 ;
6003 wxRect *arg2 = 0 ;
6004 bool result;
6005 wxRect temp2 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 char *kwnames[] = {
6009 (char *) "self",(char *) "rect", NULL
6010 };
6011
6012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6014 if (SWIG_arg_fail(1)) SWIG_fail;
6015 {
6016 arg2 = &temp2;
6017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6018 }
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6022
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 {
6027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6028 }
6029 return resultobj;
6030 fail:
6031 return NULL;
6032 }
6033
6034
6035 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6036 PyObject *resultobj;
6037 wxRect *arg1 = (wxRect *) 0 ;
6038 wxRect *arg2 = 0 ;
6039 bool result;
6040 wxRect temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "self",(char *) "rect", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6049 if (SWIG_arg_fail(1)) SWIG_fail;
6050 {
6051 arg2 = &temp2;
6052 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6053 }
6054 {
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6057
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 {
6062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6063 }
6064 return resultobj;
6065 fail:
6066 return NULL;
6067 }
6068
6069
6070 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj;
6072 wxRect *arg1 = (wxRect *) 0 ;
6073 int arg2 ;
6074 int arg3 ;
6075 bool result;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 PyObject * obj2 = 0 ;
6079 char *kwnames[] = {
6080 (char *) "self",(char *) "x",(char *) "y", NULL
6081 };
6082
6083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6085 if (SWIG_arg_fail(1)) SWIG_fail;
6086 {
6087 arg2 = (int)(SWIG_As_int(obj1));
6088 if (SWIG_arg_fail(2)) SWIG_fail;
6089 }
6090 {
6091 arg3 = (int)(SWIG_As_int(obj2));
6092 if (SWIG_arg_fail(3)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxRect *arg1 = (wxRect *) 0 ;
6113 wxPoint *arg2 = 0 ;
6114 bool result;
6115 wxPoint temp2 ;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 char *kwnames[] = {
6119 (char *) "self",(char *) "pt", NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6124 if (SWIG_arg_fail(1)) SWIG_fail;
6125 {
6126 arg2 = &temp2;
6127 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6128 }
6129 {
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6132
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 {
6137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6138 }
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj;
6147 wxRect *arg1 = (wxRect *) 0 ;
6148 wxRect *arg2 = 0 ;
6149 bool result;
6150 wxRect temp2 ;
6151 PyObject * obj0 = 0 ;
6152 PyObject * obj1 = 0 ;
6153 char *kwnames[] = {
6154 (char *) "self",(char *) "rect", NULL
6155 };
6156
6157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6159 if (SWIG_arg_fail(1)) SWIG_fail;
6160 {
6161 arg2 = &temp2;
6162 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6163 }
6164 {
6165 PyThreadState* __tstate = wxPyBeginAllowThreads();
6166 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6167
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 {
6172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6173 }
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj;
6182 wxRect *arg1 = (wxRect *) 0 ;
6183 int arg2 ;
6184 PyObject * obj0 = 0 ;
6185 PyObject * obj1 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self",(char *) "x", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 {
6194 arg2 = (int)(SWIG_As_int(obj1));
6195 if (SWIG_arg_fail(2)) SWIG_fail;
6196 }
6197 if (arg1) (arg1)->x = arg2;
6198
6199 Py_INCREF(Py_None); resultobj = Py_None;
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int result;
6210 PyObject * obj0 = 0 ;
6211 char *kwnames[] = {
6212 (char *) "self", NULL
6213 };
6214
6215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6217 if (SWIG_arg_fail(1)) SWIG_fail;
6218 result = (int) ((arg1)->x);
6219
6220 {
6221 resultobj = SWIG_From_int((int)(result));
6222 }
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 int arg2 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self",(char *) "y", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 arg2 = (int)(SWIG_As_int(obj1));
6244 if (SWIG_arg_fail(2)) SWIG_fail;
6245 }
6246 if (arg1) (arg1)->y = arg2;
6247
6248 Py_INCREF(Py_None); resultobj = Py_None;
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj;
6257 wxRect *arg1 = (wxRect *) 0 ;
6258 int result;
6259 PyObject * obj0 = 0 ;
6260 char *kwnames[] = {
6261 (char *) "self", NULL
6262 };
6263
6264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6266 if (SWIG_arg_fail(1)) SWIG_fail;
6267 result = (int) ((arg1)->y);
6268
6269 {
6270 resultobj = SWIG_From_int((int)(result));
6271 }
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int arg2 ;
6282 PyObject * obj0 = 0 ;
6283 PyObject * obj1 = 0 ;
6284 char *kwnames[] = {
6285 (char *) "self",(char *) "width", NULL
6286 };
6287
6288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 {
6292 arg2 = (int)(SWIG_As_int(obj1));
6293 if (SWIG_arg_fail(2)) SWIG_fail;
6294 }
6295 if (arg1) (arg1)->width = arg2;
6296
6297 Py_INCREF(Py_None); resultobj = Py_None;
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int result;
6308 PyObject * obj0 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 result = (int) ((arg1)->width);
6317
6318 {
6319 resultobj = SWIG_From_int((int)(result));
6320 }
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 wxRect *arg1 = (wxRect *) 0 ;
6330 int arg2 ;
6331 PyObject * obj0 = 0 ;
6332 PyObject * obj1 = 0 ;
6333 char *kwnames[] = {
6334 (char *) "self",(char *) "height", NULL
6335 };
6336
6337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6339 if (SWIG_arg_fail(1)) SWIG_fail;
6340 {
6341 arg2 = (int)(SWIG_As_int(obj1));
6342 if (SWIG_arg_fail(2)) SWIG_fail;
6343 }
6344 if (arg1) (arg1)->height = arg2;
6345
6346 Py_INCREF(Py_None); resultobj = Py_None;
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxRect *arg1 = (wxRect *) 0 ;
6356 int result;
6357 PyObject * obj0 = 0 ;
6358 char *kwnames[] = {
6359 (char *) "self", NULL
6360 };
6361
6362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6364 if (SWIG_arg_fail(1)) SWIG_fail;
6365 result = (int) ((arg1)->height);
6366
6367 {
6368 resultobj = SWIG_From_int((int)(result));
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxRect *arg1 = (wxRect *) 0 ;
6379 int arg2 = (int) 0 ;
6380 int arg3 = (int) 0 ;
6381 int arg4 = (int) 0 ;
6382 int arg5 = (int) 0 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 PyObject * obj2 = 0 ;
6386 PyObject * obj3 = 0 ;
6387 PyObject * obj4 = 0 ;
6388 char *kwnames[] = {
6389 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6390 };
6391
6392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6394 if (SWIG_arg_fail(1)) SWIG_fail;
6395 if (obj1) {
6396 {
6397 arg2 = (int)(SWIG_As_int(obj1));
6398 if (SWIG_arg_fail(2)) SWIG_fail;
6399 }
6400 }
6401 if (obj2) {
6402 {
6403 arg3 = (int)(SWIG_As_int(obj2));
6404 if (SWIG_arg_fail(3)) SWIG_fail;
6405 }
6406 }
6407 if (obj3) {
6408 {
6409 arg4 = (int)(SWIG_As_int(obj3));
6410 if (SWIG_arg_fail(4)) SWIG_fail;
6411 }
6412 }
6413 if (obj4) {
6414 {
6415 arg5 = (int)(SWIG_As_int(obj4));
6416 if (SWIG_arg_fail(5)) SWIG_fail;
6417 }
6418 }
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6422
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 Py_INCREF(Py_None); resultobj = Py_None;
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj;
6435 wxRect *arg1 = (wxRect *) 0 ;
6436 PyObject *result;
6437 PyObject * obj0 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 result = (PyObject *)wxRect_Get(arg1);
6448
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = result;
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6460 PyObject *obj;
6461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6462 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6463 Py_INCREF(obj);
6464 return Py_BuildValue((char *)"");
6465 }
6466 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxRect *arg1 = (wxRect *) 0 ;
6469 wxRect *arg2 = (wxRect *) 0 ;
6470 PyObject *result;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 char *kwnames[] = {
6474 (char *) "r1",(char *) "r2", NULL
6475 };
6476
6477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6479 if (SWIG_arg_fail(1)) SWIG_fail;
6480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6481 if (SWIG_arg_fail(2)) SWIG_fail;
6482 {
6483 if (!wxPyCheckForApp()) SWIG_fail;
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 result = (PyObject *)wxIntersectRect(arg1,arg2);
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = result;
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj;
6499 double arg1 = (double) 0.0 ;
6500 double arg2 = (double) 0.0 ;
6501 wxPoint2D *result;
6502 PyObject * obj0 = 0 ;
6503 PyObject * obj1 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "x",(char *) "y", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6509 if (obj0) {
6510 {
6511 arg1 = (double)(SWIG_As_double(obj0));
6512 if (SWIG_arg_fail(1)) SWIG_fail;
6513 }
6514 }
6515 if (obj1) {
6516 {
6517 arg2 = (double)(SWIG_As_double(obj1));
6518 if (SWIG_arg_fail(2)) SWIG_fail;
6519 }
6520 }
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 wxPoint2D *arg1 = 0 ;
6538 wxPoint2D *result;
6539 wxPoint2D temp1 ;
6540 PyObject * obj0 = 0 ;
6541 char *kwnames[] = {
6542 (char *) "pt", NULL
6543 };
6544
6545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6546 {
6547 arg1 = &temp1;
6548 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6549 }
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6553
6554 wxPyEndAllowThreads(__tstate);
6555 if (PyErr_Occurred()) SWIG_fail;
6556 }
6557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6558 return resultobj;
6559 fail:
6560 return NULL;
6561 }
6562
6563
6564 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6565 PyObject *resultobj;
6566 wxPoint *arg1 = 0 ;
6567 wxPoint2D *result;
6568 wxPoint temp1 ;
6569 PyObject * obj0 = 0 ;
6570 char *kwnames[] = {
6571 (char *) "pt", NULL
6572 };
6573
6574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6575 {
6576 arg1 = &temp1;
6577 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6578 }
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6582
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6596 int *arg2 = (int *) 0 ;
6597 int *arg3 = (int *) 0 ;
6598 int temp2 ;
6599 int res2 = 0 ;
6600 int temp3 ;
6601 int res3 = 0 ;
6602 PyObject * obj0 = 0 ;
6603 char *kwnames[] = {
6604 (char *) "self", NULL
6605 };
6606
6607 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6608 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6615
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 Py_INCREF(Py_None); resultobj = Py_None;
6620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6621 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6623 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6624 return resultobj;
6625 fail:
6626 return NULL;
6627 }
6628
6629
6630 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6631 PyObject *resultobj;
6632 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6633 int *arg2 = (int *) 0 ;
6634 int *arg3 = (int *) 0 ;
6635 int temp2 ;
6636 int res2 = 0 ;
6637 int temp3 ;
6638 int res3 = 0 ;
6639 PyObject * obj0 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self", NULL
6642 };
6643
6644 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6645 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6652
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 Py_INCREF(Py_None); resultobj = Py_None;
6657 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6658 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6659 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6660 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6668 PyObject *resultobj;
6669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6670 double result;
6671 PyObject * obj0 = 0 ;
6672 char *kwnames[] = {
6673 (char *) "self", NULL
6674 };
6675
6676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6678 if (SWIG_arg_fail(1)) SWIG_fail;
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6682
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 {
6687 resultobj = SWIG_From_double((double)(result));
6688 }
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6696 PyObject *resultobj;
6697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6698 double result;
6699 PyObject * obj0 = 0 ;
6700 char *kwnames[] = {
6701 (char *) "self", NULL
6702 };
6703
6704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6706 if (SWIG_arg_fail(1)) SWIG_fail;
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 {
6715 resultobj = SWIG_From_double((double)(result));
6716 }
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6726 double arg2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "self",(char *) "length", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6735 if (SWIG_arg_fail(1)) SWIG_fail;
6736 {
6737 arg2 = (double)(SWIG_As_double(obj1));
6738 if (SWIG_arg_fail(2)) SWIG_fail;
6739 }
6740 {
6741 PyThreadState* __tstate = wxPyBeginAllowThreads();
6742 (arg1)->SetVectorLength(arg2);
6743
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 Py_INCREF(Py_None); resultobj = Py_None;
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6755 PyObject *resultobj;
6756 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6757 double arg2 ;
6758 PyObject * obj0 = 0 ;
6759 PyObject * obj1 = 0 ;
6760 char *kwnames[] = {
6761 (char *) "self",(char *) "degrees", NULL
6762 };
6763
6764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6766 if (SWIG_arg_fail(1)) SWIG_fail;
6767 {
6768 arg2 = (double)(SWIG_As_double(obj1));
6769 if (SWIG_arg_fail(2)) SWIG_fail;
6770 }
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 (arg1)->SetVectorAngle(arg2);
6774
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 Py_INCREF(Py_None); resultobj = Py_None;
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6788 wxPoint2D *arg2 = 0 ;
6789 double result;
6790 wxPoint2D temp2 ;
6791 PyObject * obj0 = 0 ;
6792 PyObject * obj1 = 0 ;
6793 char *kwnames[] = {
6794 (char *) "self",(char *) "pt", NULL
6795 };
6796
6797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 {
6801 arg2 = &temp2;
6802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6803 }
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 {
6812 resultobj = SWIG_From_double((double)(result));
6813 }
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6821 PyObject *resultobj;
6822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6823 wxPoint2D *arg2 = 0 ;
6824 double result;
6825 wxPoint2D temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "pt", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = &temp2;
6837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6838 }
6839 {
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 {
6847 resultobj = SWIG_From_double((double)(result));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6858 wxPoint2D *arg2 = 0 ;
6859 double result;
6860 wxPoint2D temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char *kwnames[] = {
6864 (char *) "self",(char *) "vec", NULL
6865 };
6866
6867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6869 if (SWIG_arg_fail(1)) SWIG_fail;
6870 {
6871 arg2 = &temp2;
6872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6873 }
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6877
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 {
6882 resultobj = SWIG_From_double((double)(result));
6883 }
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6891 PyObject *resultobj;
6892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6893 wxPoint2D *arg2 = 0 ;
6894 double result;
6895 wxPoint2D temp2 ;
6896 PyObject * obj0 = 0 ;
6897 PyObject * obj1 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "self",(char *) "vec", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6904 if (SWIG_arg_fail(1)) SWIG_fail;
6905 {
6906 arg2 = &temp2;
6907 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6908 }
6909 {
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6912
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 {
6917 resultobj = SWIG_From_double((double)(result));
6918 }
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj;
6927 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6928 wxPoint2D result;
6929 PyObject * obj0 = 0 ;
6930 char *kwnames[] = {
6931 (char *) "self", NULL
6932 };
6933
6934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6936 if (SWIG_arg_fail(1)) SWIG_fail;
6937 {
6938 PyThreadState* __tstate = wxPyBeginAllowThreads();
6939 result = (arg1)->operator -();
6940
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 {
6945 wxPoint2D * resultptr;
6946 resultptr = new wxPoint2D((wxPoint2D &)(result));
6947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6948 }
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6958 wxPoint2D *arg2 = 0 ;
6959 wxPoint2D *result;
6960 wxPoint2D temp2 ;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "pt", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 {
6977 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6978 result = (wxPoint2D *) &_result_ref;
6979 }
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6994 wxPoint2D *arg2 = 0 ;
6995 wxPoint2D *result;
6996 wxPoint2D temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "self",(char *) "pt", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7005 if (SWIG_arg_fail(1)) SWIG_fail;
7006 {
7007 arg2 = &temp2;
7008 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7009 }
7010 {
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 {
7013 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7014 result = (wxPoint2D *) &_result_ref;
7015 }
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7030 wxPoint2D *arg2 = 0 ;
7031 wxPoint2D *result;
7032 wxPoint2D temp2 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "self",(char *) "pt", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7041 if (SWIG_arg_fail(1)) SWIG_fail;
7042 {
7043 arg2 = &temp2;
7044 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7045 }
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 {
7049 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7050 result = (wxPoint2D *) &_result_ref;
7051 }
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj;
7065 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7066 wxPoint2D *arg2 = 0 ;
7067 wxPoint2D *result;
7068 wxPoint2D temp2 ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "self",(char *) "pt", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 {
7079 arg2 = &temp2;
7080 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7081 }
7082 {
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 {
7085 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7086 result = (wxPoint2D *) &_result_ref;
7087 }
7088
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7102 wxPoint2D *arg2 = 0 ;
7103 bool result;
7104 wxPoint2D temp2 ;
7105 PyObject * obj0 = 0 ;
7106 PyObject * obj1 = 0 ;
7107 char *kwnames[] = {
7108 (char *) "self",(char *) "pt", NULL
7109 };
7110
7111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7113 if (SWIG_arg_fail(1)) SWIG_fail;
7114 {
7115 arg2 = &temp2;
7116 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7117 }
7118 {
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7121
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 {
7126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7127 }
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7137 wxPoint2D *arg2 = 0 ;
7138 bool result;
7139 wxPoint2D temp2 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 char *kwnames[] = {
7143 (char *) "self",(char *) "pt", NULL
7144 };
7145
7146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7148 if (SWIG_arg_fail(1)) SWIG_fail;
7149 {
7150 arg2 = &temp2;
7151 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7152 }
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7156
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 {
7161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7162 }
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj;
7171 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7172 double arg2 ;
7173 PyObject * obj0 = 0 ;
7174 PyObject * obj1 = 0 ;
7175 char *kwnames[] = {
7176 (char *) "self",(char *) "m_x", NULL
7177 };
7178
7179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 {
7183 arg2 = (double)(SWIG_As_double(obj1));
7184 if (SWIG_arg_fail(2)) SWIG_fail;
7185 }
7186 if (arg1) (arg1)->m_x = arg2;
7187
7188 Py_INCREF(Py_None); resultobj = Py_None;
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7198 double result;
7199 PyObject * obj0 = 0 ;
7200 char *kwnames[] = {
7201 (char *) "self", NULL
7202 };
7203
7204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(1)) SWIG_fail;
7207 result = (double) ((arg1)->m_x);
7208
7209 {
7210 resultobj = SWIG_From_double((double)(result));
7211 }
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7221 double arg2 ;
7222 PyObject * obj0 = 0 ;
7223 PyObject * obj1 = 0 ;
7224 char *kwnames[] = {
7225 (char *) "self",(char *) "m_y", NULL
7226 };
7227
7228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 {
7232 arg2 = (double)(SWIG_As_double(obj1));
7233 if (SWIG_arg_fail(2)) SWIG_fail;
7234 }
7235 if (arg1) (arg1)->m_y = arg2;
7236
7237 Py_INCREF(Py_None); resultobj = Py_None;
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7247 double result;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 result = (double) ((arg1)->m_y);
7257
7258 {
7259 resultobj = SWIG_From_double((double)(result));
7260 }
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7270 double arg2 = (double) 0 ;
7271 double arg3 = (double) 0 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 PyObject * obj2 = 0 ;
7275 char *kwnames[] = {
7276 (char *) "self",(char *) "x",(char *) "y", NULL
7277 };
7278
7279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7281 if (SWIG_arg_fail(1)) SWIG_fail;
7282 if (obj1) {
7283 {
7284 arg2 = (double)(SWIG_As_double(obj1));
7285 if (SWIG_arg_fail(2)) SWIG_fail;
7286 }
7287 }
7288 if (obj2) {
7289 {
7290 arg3 = (double)(SWIG_As_double(obj2));
7291 if (SWIG_arg_fail(3)) SWIG_fail;
7292 }
7293 }
7294 {
7295 PyThreadState* __tstate = wxPyBeginAllowThreads();
7296 wxPoint2D_Set(arg1,arg2,arg3);
7297
7298 wxPyEndAllowThreads(__tstate);
7299 if (PyErr_Occurred()) SWIG_fail;
7300 }
7301 Py_INCREF(Py_None); resultobj = Py_None;
7302 return resultobj;
7303 fail:
7304 return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7311 PyObject *result;
7312 PyObject * obj0 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "self", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7319 if (SWIG_arg_fail(1)) SWIG_fail;
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (PyObject *)wxPoint2D_Get(arg1);
7323
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 resultobj = result;
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7335 PyObject *obj;
7336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7337 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7338 Py_INCREF(obj);
7339 return Py_BuildValue((char *)"");
7340 }
7341 static int _wrap_DefaultPosition_set(PyObject *) {
7342 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7343 return 1;
7344 }
7345
7346
7347 static PyObject *_wrap_DefaultPosition_get(void) {
7348 PyObject *pyobj;
7349
7350 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7351 return pyobj;
7352 }
7353
7354
7355 static int _wrap_DefaultSize_set(PyObject *) {
7356 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7357 return 1;
7358 }
7359
7360
7361 static PyObject *_wrap_DefaultSize_get(void) {
7362 PyObject *pyobj;
7363
7364 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7365 return pyobj;
7366 }
7367
7368
7369 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 PyObject *arg1 = (PyObject *) 0 ;
7372 wxPyInputStream *result;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "p", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7379 arg1 = obj0;
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7383
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj;
7396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7397 PyObject * obj0 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 PyThreadState* __tstate = wxPyBeginAllowThreads();
7407 delete arg1;
7408
7409 wxPyEndAllowThreads(__tstate);
7410 if (PyErr_Occurred()) SWIG_fail;
7411 }
7412 Py_INCREF(Py_None); resultobj = Py_None;
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7422 PyObject * obj0 = 0 ;
7423 char *kwnames[] = {
7424 (char *) "self", NULL
7425 };
7426
7427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(1)) SWIG_fail;
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 (arg1)->close();
7433
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 Py_INCREF(Py_None); resultobj = Py_None;
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7445 PyObject *resultobj;
7446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7447 PyObject * obj0 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 (arg1)->flush();
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 Py_INCREF(Py_None); resultobj = Py_None;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7472 bool result;
7473 PyObject * obj0 = 0 ;
7474 char *kwnames[] = {
7475 (char *) "self", NULL
7476 };
7477
7478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7480 if (SWIG_arg_fail(1)) SWIG_fail;
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)(arg1)->eof();
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 {
7489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7490 }
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj;
7499 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7500 int arg2 = (int) -1 ;
7501 PyObject *result;
7502 PyObject * obj0 = 0 ;
7503 PyObject * obj1 = 0 ;
7504 char *kwnames[] = {
7505 (char *) "self",(char *) "size", NULL
7506 };
7507
7508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7510 if (SWIG_arg_fail(1)) SWIG_fail;
7511 if (obj1) {
7512 {
7513 arg2 = (int)(SWIG_As_int(obj1));
7514 if (SWIG_arg_fail(2)) SWIG_fail;
7515 }
7516 }
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (PyObject *)(arg1)->read(arg2);
7520
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 resultobj = result;
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj;
7533 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7534 int arg2 = (int) -1 ;
7535 PyObject *result;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char *kwnames[] = {
7539 (char *) "self",(char *) "size", NULL
7540 };
7541
7542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7544 if (SWIG_arg_fail(1)) SWIG_fail;
7545 if (obj1) {
7546 {
7547 arg2 = (int)(SWIG_As_int(obj1));
7548 if (SWIG_arg_fail(2)) SWIG_fail;
7549 }
7550 }
7551 {
7552 PyThreadState* __tstate = wxPyBeginAllowThreads();
7553 result = (PyObject *)(arg1)->readline(arg2);
7554
7555 wxPyEndAllowThreads(__tstate);
7556 if (PyErr_Occurred()) SWIG_fail;
7557 }
7558 resultobj = result;
7559 return resultobj;
7560 fail:
7561 return NULL;
7562 }
7563
7564
7565 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7566 PyObject *resultobj;
7567 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7568 int arg2 = (int) -1 ;
7569 PyObject *result;
7570 PyObject * obj0 = 0 ;
7571 PyObject * obj1 = 0 ;
7572 char *kwnames[] = {
7573 (char *) "self",(char *) "sizehint", NULL
7574 };
7575
7576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7578 if (SWIG_arg_fail(1)) SWIG_fail;
7579 if (obj1) {
7580 {
7581 arg2 = (int)(SWIG_As_int(obj1));
7582 if (SWIG_arg_fail(2)) SWIG_fail;
7583 }
7584 }
7585 {
7586 PyThreadState* __tstate = wxPyBeginAllowThreads();
7587 result = (PyObject *)(arg1)->readlines(arg2);
7588
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 resultobj = result;
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7600 PyObject *resultobj;
7601 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7602 int arg2 ;
7603 int arg3 = (int) 0 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 PyObject * obj2 = 0 ;
7607 char *kwnames[] = {
7608 (char *) "self",(char *) "offset",(char *) "whence", NULL
7609 };
7610
7611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7613 if (SWIG_arg_fail(1)) SWIG_fail;
7614 {
7615 arg2 = (int)(SWIG_As_int(obj1));
7616 if (SWIG_arg_fail(2)) SWIG_fail;
7617 }
7618 if (obj2) {
7619 {
7620 arg3 = (int)(SWIG_As_int(obj2));
7621 if (SWIG_arg_fail(3)) SWIG_fail;
7622 }
7623 }
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 (arg1)->seek(arg2,arg3);
7627
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 Py_INCREF(Py_None); resultobj = Py_None;
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7639 PyObject *resultobj;
7640 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7641 int result;
7642 PyObject * obj0 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "self", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(1)) SWIG_fail;
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 result = (int)(arg1)->tell();
7653
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = SWIG_From_int((int)(result));
7659 }
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj;
7668 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7669 char result;
7670 PyObject * obj0 = 0 ;
7671 char *kwnames[] = {
7672 (char *) "self", NULL
7673 };
7674
7675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7677 if (SWIG_arg_fail(1)) SWIG_fail;
7678 {
7679 PyThreadState* __tstate = wxPyBeginAllowThreads();
7680 result = (char)(arg1)->Peek();
7681
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 {
7686 resultobj = SWIG_From_char((char)(result));
7687 }
7688 return resultobj;
7689 fail:
7690 return NULL;
7691 }
7692
7693
7694 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7695 PyObject *resultobj;
7696 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7697 char result;
7698 PyObject * obj0 = 0 ;
7699 char *kwnames[] = {
7700 (char *) "self", NULL
7701 };
7702
7703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7705 if (SWIG_arg_fail(1)) SWIG_fail;
7706 {
7707 PyThreadState* __tstate = wxPyBeginAllowThreads();
7708 result = (char)(arg1)->GetC();
7709
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 {
7714 resultobj = SWIG_From_char((char)(result));
7715 }
7716 return resultobj;
7717 fail:
7718 return NULL;
7719 }
7720
7721
7722 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7723 PyObject *resultobj;
7724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7725 size_t result;
7726 PyObject * obj0 = 0 ;
7727 char *kwnames[] = {
7728 (char *) "self", NULL
7729 };
7730
7731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7733 if (SWIG_arg_fail(1)) SWIG_fail;
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 result = (size_t)(arg1)->LastRead();
7737
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 {
7742 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7743 }
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj;
7752 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7753 bool result;
7754 PyObject * obj0 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)(arg1)->CanRead();
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7781 bool result;
7782 PyObject * obj0 = 0 ;
7783 char *kwnames[] = {
7784 (char *) "self", NULL
7785 };
7786
7787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7789 if (SWIG_arg_fail(1)) SWIG_fail;
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = (bool)(arg1)->Eof();
7793
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7799 }
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj;
7808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7809 char arg2 ;
7810 bool result;
7811 PyObject * obj0 = 0 ;
7812 PyObject * obj1 = 0 ;
7813 char *kwnames[] = {
7814 (char *) "self",(char *) "c", NULL
7815 };
7816
7817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7819 if (SWIG_arg_fail(1)) SWIG_fail;
7820 {
7821 arg2 = (char)(SWIG_As_char(obj1));
7822 if (SWIG_arg_fail(2)) SWIG_fail;
7823 }
7824 {
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 result = (bool)(arg1)->Ungetch(arg2);
7827
7828 wxPyEndAllowThreads(__tstate);
7829 if (PyErr_Occurred()) SWIG_fail;
7830 }
7831 {
7832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7833 }
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7841 PyObject *resultobj;
7842 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7843 long arg2 ;
7844 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7845 long result;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 PyObject * obj2 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self",(char *) "pos",(char *) "mode", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 {
7857 arg2 = (long)(SWIG_As_long(obj1));
7858 if (SWIG_arg_fail(2)) SWIG_fail;
7859 }
7860 if (obj2) {
7861 {
7862 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7863 if (SWIG_arg_fail(3)) SWIG_fail;
7864 }
7865 }
7866 {
7867 PyThreadState* __tstate = wxPyBeginAllowThreads();
7868 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7869
7870 wxPyEndAllowThreads(__tstate);
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 {
7874 resultobj = SWIG_From_long((long)(result));
7875 }
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7885 long result;
7886 PyObject * obj0 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 result = (long)(arg1)->TellI();
7897
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 {
7902 resultobj = SWIG_From_long((long)(result));
7903 }
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7911 PyObject *obj;
7912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7913 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7914 Py_INCREF(obj);
7915 return Py_BuildValue((char *)"");
7916 }
7917 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj;
7919 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7920 PyObject *arg2 = (PyObject *) 0 ;
7921 PyObject * obj0 = 0 ;
7922 PyObject * obj1 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "self",(char *) "obj", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(1)) SWIG_fail;
7930 arg2 = obj1;
7931 {
7932 PyThreadState* __tstate = wxPyBeginAllowThreads();
7933 wxOutputStream_write(arg1,arg2);
7934
7935 wxPyEndAllowThreads(__tstate);
7936 if (PyErr_Occurred()) SWIG_fail;
7937 }
7938 Py_INCREF(Py_None); resultobj = Py_None;
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7946 PyObject *obj;
7947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7948 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7949 Py_INCREF(obj);
7950 return Py_BuildValue((char *)"");
7951 }
7952 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxInputStream *arg1 = (wxInputStream *) 0 ;
7955 wxString *arg2 = 0 ;
7956 wxString *arg3 = 0 ;
7957 wxString *arg4 = 0 ;
7958 wxDateTime arg5 ;
7959 wxFSFile *result;
7960 wxPyInputStream *temp1 ;
7961 bool temp2 = false ;
7962 bool temp3 = false ;
7963 bool temp4 = false ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 PyObject * obj2 = 0 ;
7967 PyObject * obj3 = 0 ;
7968 PyObject * obj4 = 0 ;
7969 char *kwnames[] = {
7970 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7971 };
7972
7973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7974 {
7975 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7976 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7977 } else {
7978 PyErr_Clear(); // clear the failure of the wxPyConvert above
7979 arg1 = wxPyCBInputStream_create(obj0, true);
7980 if (arg1 == NULL) {
7981 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7982 SWIG_fail;
7983 }
7984 }
7985 }
7986 {
7987 arg2 = wxString_in_helper(obj1);
7988 if (arg2 == NULL) SWIG_fail;
7989 temp2 = true;
7990 }
7991 {
7992 arg3 = wxString_in_helper(obj2);
7993 if (arg3 == NULL) SWIG_fail;
7994 temp3 = true;
7995 }
7996 {
7997 arg4 = wxString_in_helper(obj3);
7998 if (arg4 == NULL) SWIG_fail;
7999 temp4 = true;
8000 }
8001 {
8002 wxDateTime * argp;
8003 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8004 if (SWIG_arg_fail(5)) SWIG_fail;
8005 if (argp == NULL) {
8006 SWIG_null_ref("wxDateTime");
8007 }
8008 if (SWIG_arg_fail(5)) SWIG_fail;
8009 arg5 = *argp;
8010 }
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 {
8019 resultobj = wxPyMake_wxObject(result, 1);
8020 }
8021 {
8022 if (temp2)
8023 delete arg2;
8024 }
8025 {
8026 if (temp3)
8027 delete arg3;
8028 }
8029 {
8030 if (temp4)
8031 delete arg4;
8032 }
8033 return resultobj;
8034 fail:
8035 {
8036 if (temp2)
8037 delete arg2;
8038 }
8039 {
8040 if (temp3)
8041 delete arg3;
8042 }
8043 {
8044 if (temp4)
8045 delete arg4;
8046 }
8047 return NULL;
8048 }
8049
8050
8051 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj;
8053 wxFSFile *arg1 = (wxFSFile *) 0 ;
8054 PyObject * obj0 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 delete arg1;
8065
8066 wxPyEndAllowThreads(__tstate);
8067 if (PyErr_Occurred()) SWIG_fail;
8068 }
8069 Py_INCREF(Py_None); resultobj = Py_None;
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8077 PyObject *resultobj;
8078 wxFSFile *arg1 = (wxFSFile *) 0 ;
8079 wxInputStream *result;
8080 PyObject * obj0 = 0 ;
8081 char *kwnames[] = {
8082 (char *) "self", NULL
8083 };
8084
8085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(1)) SWIG_fail;
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 result = (wxInputStream *)(arg1)->GetStream();
8091
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 {
8096 wxPyInputStream * _ptr = NULL;
8097
8098 if (result) {
8099 _ptr = new wxPyInputStream(result);
8100 }
8101 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8110 PyObject *resultobj;
8111 wxFSFile *arg1 = (wxFSFile *) 0 ;
8112 wxString *result;
8113 PyObject * obj0 = 0 ;
8114 char *kwnames[] = {
8115 (char *) "self", NULL
8116 };
8117
8118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8120 if (SWIG_arg_fail(1)) SWIG_fail;
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 {
8124 wxString const &_result_ref = (arg1)->GetMimeType();
8125 result = (wxString *) &_result_ref;
8126 }
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 {
8132 #if wxUSE_UNICODE
8133 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8134 #else
8135 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8136 #endif
8137 }
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj;
8146 wxFSFile *arg1 = (wxFSFile *) 0 ;
8147 wxString *result;
8148 PyObject * obj0 = 0 ;
8149 char *kwnames[] = {
8150 (char *) "self", NULL
8151 };
8152
8153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8155 if (SWIG_arg_fail(1)) SWIG_fail;
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 {
8159 wxString const &_result_ref = (arg1)->GetLocation();
8160 result = (wxString *) &_result_ref;
8161 }
8162
8163 wxPyEndAllowThreads(__tstate);
8164 if (PyErr_Occurred()) SWIG_fail;
8165 }
8166 {
8167 #if wxUSE_UNICODE
8168 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8169 #else
8170 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8171 #endif
8172 }
8173 return resultobj;
8174 fail:
8175 return NULL;
8176 }
8177
8178
8179 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj;
8181 wxFSFile *arg1 = (wxFSFile *) 0 ;
8182 wxString *result;
8183 PyObject * obj0 = 0 ;
8184 char *kwnames[] = {
8185 (char *) "self", NULL
8186 };
8187
8188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8190 if (SWIG_arg_fail(1)) SWIG_fail;
8191 {
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 {
8194 wxString const &_result_ref = (arg1)->GetAnchor();
8195 result = (wxString *) &_result_ref;
8196 }
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 {
8202 #if wxUSE_UNICODE
8203 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8204 #else
8205 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8206 #endif
8207 }
8208 return resultobj;
8209 fail:
8210 return NULL;
8211 }
8212
8213
8214 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8215 PyObject *resultobj;
8216 wxFSFile *arg1 = (wxFSFile *) 0 ;
8217 wxDateTime result;
8218 PyObject * obj0 = 0 ;
8219 char *kwnames[] = {
8220 (char *) "self", NULL
8221 };
8222
8223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8225 if (SWIG_arg_fail(1)) SWIG_fail;
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (arg1)->GetModificationTime();
8229
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 {
8234 wxDateTime * resultptr;
8235 resultptr = new wxDateTime((wxDateTime &)(result));
8236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8237 }
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8245 PyObject *obj;
8246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8247 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8248 Py_INCREF(obj);
8249 return Py_BuildValue((char *)"");
8250 }
8251 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8252 PyObject *obj;
8253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8254 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8255 Py_INCREF(obj);
8256 return Py_BuildValue((char *)"");
8257 }
8258 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyFileSystemHandler *result;
8261 char *kwnames[] = {
8262 NULL
8263 };
8264
8265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj;
8282 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8283 PyObject *arg2 = (PyObject *) 0 ;
8284 PyObject *arg3 = (PyObject *) 0 ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 PyObject * obj2 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self",(char *) "self",(char *) "_class", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 arg2 = obj1;
8296 arg3 = obj2;
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 (arg1)->_setCallbackInfo(arg2,arg3);
8300
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 Py_INCREF(Py_None); resultobj = Py_None;
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj;
8313 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8314 wxString *arg2 = 0 ;
8315 bool result;
8316 bool temp2 = false ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self",(char *) "location", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 arg2 = wxString_in_helper(obj1);
8328 if (arg2 == NULL) SWIG_fail;
8329 temp2 = true;
8330 }
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 {
8339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8340 }
8341 {
8342 if (temp2)
8343 delete arg2;
8344 }
8345 return resultobj;
8346 fail:
8347 {
8348 if (temp2)
8349 delete arg2;
8350 }
8351 return NULL;
8352 }
8353
8354
8355 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj;
8357 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8358 wxFileSystem *arg2 = 0 ;
8359 wxString *arg3 = 0 ;
8360 wxFSFile *result;
8361 bool temp3 = false ;
8362 PyObject * obj0 = 0 ;
8363 PyObject * obj1 = 0 ;
8364 PyObject * obj2 = 0 ;
8365 char *kwnames[] = {
8366 (char *) "self",(char *) "fs",(char *) "location", NULL
8367 };
8368
8369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(1)) SWIG_fail;
8372 {
8373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8374 if (SWIG_arg_fail(2)) SWIG_fail;
8375 if (arg2 == NULL) {
8376 SWIG_null_ref("wxFileSystem");
8377 }
8378 if (SWIG_arg_fail(2)) SWIG_fail;
8379 }
8380 {
8381 arg3 = wxString_in_helper(obj2);
8382 if (arg3 == NULL) SWIG_fail;
8383 temp3 = true;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 resultobj = wxPyMake_wxObject(result, 1);
8394 }
8395 {
8396 if (temp3)
8397 delete arg3;
8398 }
8399 return resultobj;
8400 fail:
8401 {
8402 if (temp3)
8403 delete arg3;
8404 }
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj;
8411 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8412 wxString *arg2 = 0 ;
8413 int arg3 = (int) 0 ;
8414 wxString result;
8415 bool temp2 = false ;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self",(char *) "spec",(char *) "flags", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 {
8427 arg2 = wxString_in_helper(obj1);
8428 if (arg2 == NULL) SWIG_fail;
8429 temp2 = true;
8430 }
8431 if (obj2) {
8432 {
8433 arg3 = (int)(SWIG_As_int(obj2));
8434 if (SWIG_arg_fail(3)) SWIG_fail;
8435 }
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8440
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 #if wxUSE_UNICODE
8446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8447 #else
8448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8449 #endif
8450 }
8451 {
8452 if (temp2)
8453 delete arg2;
8454 }
8455 return resultobj;
8456 fail:
8457 {
8458 if (temp2)
8459 delete arg2;
8460 }
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8468 wxString result;
8469 PyObject * obj0 = 0 ;
8470 char *kwnames[] = {
8471 (char *) "self", NULL
8472 };
8473
8474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (arg1)->FindNext();
8480
8481 wxPyEndAllowThreads(__tstate);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 {
8485 #if wxUSE_UNICODE
8486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8487 #else
8488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8489 #endif
8490 }
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj;
8499 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8500 wxString *arg2 = 0 ;
8501 wxString result;
8502 bool temp2 = false ;
8503 PyObject * obj0 = 0 ;
8504 PyObject * obj1 = 0 ;
8505 char *kwnames[] = {
8506 (char *) "self",(char *) "location", NULL
8507 };
8508
8509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8511 if (SWIG_arg_fail(1)) SWIG_fail;
8512 {
8513 arg2 = wxString_in_helper(obj1);
8514 if (arg2 == NULL) SWIG_fail;
8515 temp2 = true;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (arg1)->GetProtocol((wxString const &)*arg2);
8520
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 {
8525 #if wxUSE_UNICODE
8526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8527 #else
8528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8529 #endif
8530 }
8531 {
8532 if (temp2)
8533 delete arg2;
8534 }
8535 return resultobj;
8536 fail:
8537 {
8538 if (temp2)
8539 delete arg2;
8540 }
8541 return NULL;
8542 }
8543
8544
8545 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8546 PyObject *resultobj;
8547 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8548 wxString *arg2 = 0 ;
8549 wxString result;
8550 bool temp2 = false ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "self",(char *) "location", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 {
8561 arg2 = wxString_in_helper(obj1);
8562 if (arg2 == NULL) SWIG_fail;
8563 temp2 = true;
8564 }
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8568
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 {
8573 #if wxUSE_UNICODE
8574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8575 #else
8576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8577 #endif
8578 }
8579 {
8580 if (temp2)
8581 delete arg2;
8582 }
8583 return resultobj;
8584 fail:
8585 {
8586 if (temp2)
8587 delete arg2;
8588 }
8589 return NULL;
8590 }
8591
8592
8593 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj;
8595 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8596 wxString *arg2 = 0 ;
8597 wxString result;
8598 bool temp2 = false ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char *kwnames[] = {
8602 (char *) "self",(char *) "location", NULL
8603 };
8604
8605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 {
8609 arg2 = wxString_in_helper(obj1);
8610 if (arg2 == NULL) SWIG_fail;
8611 temp2 = true;
8612 }
8613 {
8614 PyThreadState* __tstate = wxPyBeginAllowThreads();
8615 result = (arg1)->GetAnchor((wxString const &)*arg2);
8616
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 {
8621 #if wxUSE_UNICODE
8622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8623 #else
8624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8625 #endif
8626 }
8627 {
8628 if (temp2)
8629 delete arg2;
8630 }
8631 return resultobj;
8632 fail:
8633 {
8634 if (temp2)
8635 delete arg2;
8636 }
8637 return NULL;
8638 }
8639
8640
8641 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj;
8643 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8644 wxString *arg2 = 0 ;
8645 wxString result;
8646 bool temp2 = false ;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char *kwnames[] = {
8650 (char *) "self",(char *) "location", NULL
8651 };
8652
8653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8655 if (SWIG_arg_fail(1)) SWIG_fail;
8656 {
8657 arg2 = wxString_in_helper(obj1);
8658 if (arg2 == NULL) SWIG_fail;
8659 temp2 = true;
8660 }
8661 {
8662 PyThreadState* __tstate = wxPyBeginAllowThreads();
8663 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8664
8665 wxPyEndAllowThreads(__tstate);
8666 if (PyErr_Occurred()) SWIG_fail;
8667 }
8668 {
8669 #if wxUSE_UNICODE
8670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8671 #else
8672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8673 #endif
8674 }
8675 {
8676 if (temp2)
8677 delete arg2;
8678 }
8679 return resultobj;
8680 fail:
8681 {
8682 if (temp2)
8683 delete arg2;
8684 }
8685 return NULL;
8686 }
8687
8688
8689 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8690 PyObject *resultobj;
8691 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8692 wxString *arg2 = 0 ;
8693 wxString result;
8694 bool temp2 = false ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char *kwnames[] = {
8698 (char *) "self",(char *) "location", NULL
8699 };
8700
8701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8703 if (SWIG_arg_fail(1)) SWIG_fail;
8704 {
8705 arg2 = wxString_in_helper(obj1);
8706 if (arg2 == NULL) SWIG_fail;
8707 temp2 = true;
8708 }
8709 {
8710 PyThreadState* __tstate = wxPyBeginAllowThreads();
8711 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8712
8713 wxPyEndAllowThreads(__tstate);
8714 if (PyErr_Occurred()) SWIG_fail;
8715 }
8716 {
8717 #if wxUSE_UNICODE
8718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8719 #else
8720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8721 #endif
8722 }
8723 {
8724 if (temp2)
8725 delete arg2;
8726 }
8727 return resultobj;
8728 fail:
8729 {
8730 if (temp2)
8731 delete arg2;
8732 }
8733 return NULL;
8734 }
8735
8736
8737 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8738 PyObject *obj;
8739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8740 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8741 Py_INCREF(obj);
8742 return Py_BuildValue((char *)"");
8743 }
8744 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj;
8746 wxFileSystem *result;
8747 char *kwnames[] = {
8748 NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8752 {
8753 PyThreadState* __tstate = wxPyBeginAllowThreads();
8754 result = (wxFileSystem *)new wxFileSystem();
8755
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 {
8760 resultobj = wxPyMake_wxObject(result, 1);
8761 }
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8769 PyObject *resultobj;
8770 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8771 PyObject * obj0 = 0 ;
8772 char *kwnames[] = {
8773 (char *) "self", NULL
8774 };
8775
8776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8778 if (SWIG_arg_fail(1)) SWIG_fail;
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 delete arg1;
8782
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 Py_INCREF(Py_None); resultobj = Py_None;
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj;
8795 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8796 wxString *arg2 = 0 ;
8797 bool arg3 = (bool) false ;
8798 bool temp2 = false ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char *kwnames[] = {
8803 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8804 };
8805
8806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8808 if (SWIG_arg_fail(1)) SWIG_fail;
8809 {
8810 arg2 = wxString_in_helper(obj1);
8811 if (arg2 == NULL) SWIG_fail;
8812 temp2 = true;
8813 }
8814 if (obj2) {
8815 {
8816 arg3 = (bool)(SWIG_As_bool(obj2));
8817 if (SWIG_arg_fail(3)) SWIG_fail;
8818 }
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8823
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 Py_INCREF(Py_None); resultobj = Py_None;
8828 {
8829 if (temp2)
8830 delete arg2;
8831 }
8832 return resultobj;
8833 fail:
8834 {
8835 if (temp2)
8836 delete arg2;
8837 }
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8845 wxString result;
8846 PyObject * obj0 = 0 ;
8847 char *kwnames[] = {
8848 (char *) "self", NULL
8849 };
8850
8851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8853 if (SWIG_arg_fail(1)) SWIG_fail;
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (arg1)->GetPath();
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 {
8862 #if wxUSE_UNICODE
8863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8864 #else
8865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8866 #endif
8867 }
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8877 wxString *arg2 = 0 ;
8878 wxFSFile *result;
8879 bool temp2 = false ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "self",(char *) "location", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 {
8890 arg2 = wxString_in_helper(obj1);
8891 if (arg2 == NULL) SWIG_fail;
8892 temp2 = true;
8893 }
8894 {
8895 PyThreadState* __tstate = wxPyBeginAllowThreads();
8896 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8897
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 {
8902 resultobj = wxPyMake_wxObject(result, 1);
8903 }
8904 {
8905 if (temp2)
8906 delete arg2;
8907 }
8908 return resultobj;
8909 fail:
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return NULL;
8915 }
8916
8917
8918 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj;
8920 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8921 wxString *arg2 = 0 ;
8922 int arg3 = (int) 0 ;
8923 wxString result;
8924 bool temp2 = false ;
8925 PyObject * obj0 = 0 ;
8926 PyObject * obj1 = 0 ;
8927 PyObject * obj2 = 0 ;
8928 char *kwnames[] = {
8929 (char *) "self",(char *) "spec",(char *) "flags", NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(1)) SWIG_fail;
8935 {
8936 arg2 = wxString_in_helper(obj1);
8937 if (arg2 == NULL) SWIG_fail;
8938 temp2 = true;
8939 }
8940 if (obj2) {
8941 {
8942 arg3 = (int)(SWIG_As_int(obj2));
8943 if (SWIG_arg_fail(3)) SWIG_fail;
8944 }
8945 }
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 {
8954 #if wxUSE_UNICODE
8955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8956 #else
8957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8958 #endif
8959 }
8960 {
8961 if (temp2)
8962 delete arg2;
8963 }
8964 return resultobj;
8965 fail:
8966 {
8967 if (temp2)
8968 delete arg2;
8969 }
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8977 wxString result;
8978 PyObject * obj0 = 0 ;
8979 char *kwnames[] = {
8980 (char *) "self", NULL
8981 };
8982
8983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8985 if (SWIG_arg_fail(1)) SWIG_fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (arg1)->FindNext();
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 {
8994 #if wxUSE_UNICODE
8995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8996 #else
8997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8998 #endif
8999 }
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9009 PyObject * obj0 = 0 ;
9010 char *kwnames[] = {
9011 (char *) "handler", NULL
9012 };
9013
9014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9016 if (SWIG_arg_fail(1)) SWIG_fail;
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxFileSystem::AddHandler(arg1);
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 Py_INCREF(Py_None); resultobj = Py_None;
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 char *kwnames[] = {
9034 NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 wxFileSystem::CleanUpHandlers();
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxString *arg1 = 0 ;
9055 wxString result;
9056 bool temp1 = false ;
9057 PyObject * obj0 = 0 ;
9058 char *kwnames[] = {
9059 (char *) "filename", NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9063 {
9064 arg1 = wxString_in_helper(obj0);
9065 if (arg1 == NULL) SWIG_fail;
9066 temp1 = true;
9067 }
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9071
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 {
9076 #if wxUSE_UNICODE
9077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9078 #else
9079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9080 #endif
9081 }
9082 {
9083 if (temp1)
9084 delete arg1;
9085 }
9086 return resultobj;
9087 fail:
9088 {
9089 if (temp1)
9090 delete arg1;
9091 }
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxString *arg1 = 0 ;
9099 wxString result;
9100 bool temp1 = false ;
9101 PyObject * obj0 = 0 ;
9102 char *kwnames[] = {
9103 (char *) "url", NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9107 {
9108 arg1 = wxString_in_helper(obj0);
9109 if (arg1 == NULL) SWIG_fail;
9110 temp1 = true;
9111 }
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 result = FileSystem_URLToFileName((wxString const &)*arg1);
9115
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 {
9120 #if wxUSE_UNICODE
9121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9122 #else
9123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9124 #endif
9125 }
9126 {
9127 if (temp1)
9128 delete arg1;
9129 }
9130 return resultobj;
9131 fail:
9132 {
9133 if (temp1)
9134 delete arg1;
9135 }
9136 return NULL;
9137 }
9138
9139
9140 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9141 PyObject *obj;
9142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9143 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9144 Py_INCREF(obj);
9145 return Py_BuildValue((char *)"");
9146 }
9147 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9148 PyObject *resultobj;
9149 wxInternetFSHandler *result;
9150 char *kwnames[] = {
9151 NULL
9152 };
9153
9154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9163 return resultobj;
9164 fail:
9165 return NULL;
9166 }
9167
9168
9169 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj;
9171 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9172 wxString *arg2 = 0 ;
9173 bool result;
9174 bool temp2 = false ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 char *kwnames[] = {
9178 (char *) "self",(char *) "location", NULL
9179 };
9180
9181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9183 if (SWIG_arg_fail(1)) SWIG_fail;
9184 {
9185 arg2 = wxString_in_helper(obj1);
9186 if (arg2 == NULL) SWIG_fail;
9187 temp2 = true;
9188 }
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 {
9197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9198 }
9199 {
9200 if (temp2)
9201 delete arg2;
9202 }
9203 return resultobj;
9204 fail:
9205 {
9206 if (temp2)
9207 delete arg2;
9208 }
9209 return NULL;
9210 }
9211
9212
9213 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9216 wxFileSystem *arg2 = 0 ;
9217 wxString *arg3 = 0 ;
9218 wxFSFile *result;
9219 bool temp3 = false ;
9220 PyObject * obj0 = 0 ;
9221 PyObject * obj1 = 0 ;
9222 PyObject * obj2 = 0 ;
9223 char *kwnames[] = {
9224 (char *) "self",(char *) "fs",(char *) "location", NULL
9225 };
9226
9227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9229 if (SWIG_arg_fail(1)) SWIG_fail;
9230 {
9231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9232 if (SWIG_arg_fail(2)) SWIG_fail;
9233 if (arg2 == NULL) {
9234 SWIG_null_ref("wxFileSystem");
9235 }
9236 if (SWIG_arg_fail(2)) SWIG_fail;
9237 }
9238 {
9239 arg3 = wxString_in_helper(obj2);
9240 if (arg3 == NULL) SWIG_fail;
9241 temp3 = true;
9242 }
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 resultobj = wxPyMake_wxObject(result, 1);
9252 }
9253 {
9254 if (temp3)
9255 delete arg3;
9256 }
9257 return resultobj;
9258 fail:
9259 {
9260 if (temp3)
9261 delete arg3;
9262 }
9263 return NULL;
9264 }
9265
9266
9267 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9268 PyObject *obj;
9269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9270 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9271 Py_INCREF(obj);
9272 return Py_BuildValue((char *)"");
9273 }
9274 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj;
9276 wxZipFSHandler *result;
9277 char *kwnames[] = {
9278 NULL
9279 };
9280
9281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (wxZipFSHandler *)new wxZipFSHandler();
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9299 wxString *arg2 = 0 ;
9300 bool result;
9301 bool temp2 = false ;
9302 PyObject * obj0 = 0 ;
9303 PyObject * obj1 = 0 ;
9304 char *kwnames[] = {
9305 (char *) "self",(char *) "location", NULL
9306 };
9307
9308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9310 if (SWIG_arg_fail(1)) SWIG_fail;
9311 {
9312 arg2 = wxString_in_helper(obj1);
9313 if (arg2 == NULL) SWIG_fail;
9314 temp2 = true;
9315 }
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9319
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 {
9324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9325 }
9326 {
9327 if (temp2)
9328 delete arg2;
9329 }
9330 return resultobj;
9331 fail:
9332 {
9333 if (temp2)
9334 delete arg2;
9335 }
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9343 wxFileSystem *arg2 = 0 ;
9344 wxString *arg3 = 0 ;
9345 wxFSFile *result;
9346 bool temp3 = false ;
9347 PyObject * obj0 = 0 ;
9348 PyObject * obj1 = 0 ;
9349 PyObject * obj2 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "self",(char *) "fs",(char *) "location", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9359 if (SWIG_arg_fail(2)) SWIG_fail;
9360 if (arg2 == NULL) {
9361 SWIG_null_ref("wxFileSystem");
9362 }
9363 if (SWIG_arg_fail(2)) SWIG_fail;
9364 }
9365 {
9366 arg3 = wxString_in_helper(obj2);
9367 if (arg3 == NULL) SWIG_fail;
9368 temp3 = true;
9369 }
9370 {
9371 PyThreadState* __tstate = wxPyBeginAllowThreads();
9372 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9373
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 resultobj = wxPyMake_wxObject(result, 1);
9379 }
9380 {
9381 if (temp3)
9382 delete arg3;
9383 }
9384 return resultobj;
9385 fail:
9386 {
9387 if (temp3)
9388 delete arg3;
9389 }
9390 return NULL;
9391 }
9392
9393
9394 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj;
9396 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9397 wxString *arg2 = 0 ;
9398 int arg3 = (int) 0 ;
9399 wxString result;
9400 bool temp2 = false ;
9401 PyObject * obj0 = 0 ;
9402 PyObject * obj1 = 0 ;
9403 PyObject * obj2 = 0 ;
9404 char *kwnames[] = {
9405 (char *) "self",(char *) "spec",(char *) "flags", NULL
9406 };
9407
9408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9410 if (SWIG_arg_fail(1)) SWIG_fail;
9411 {
9412 arg2 = wxString_in_helper(obj1);
9413 if (arg2 == NULL) SWIG_fail;
9414 temp2 = true;
9415 }
9416 if (obj2) {
9417 {
9418 arg3 = (int)(SWIG_As_int(obj2));
9419 if (SWIG_arg_fail(3)) SWIG_fail;
9420 }
9421 }
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9425
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 #if wxUSE_UNICODE
9431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9432 #else
9433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9434 #endif
9435 }
9436 {
9437 if (temp2)
9438 delete arg2;
9439 }
9440 return resultobj;
9441 fail:
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return NULL;
9447 }
9448
9449
9450 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj;
9452 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9453 wxString result;
9454 PyObject * obj0 = 0 ;
9455 char *kwnames[] = {
9456 (char *) "self", NULL
9457 };
9458
9459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9461 if (SWIG_arg_fail(1)) SWIG_fail;
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = (arg1)->FindNext();
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 {
9470 #if wxUSE_UNICODE
9471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9472 #else
9473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9474 #endif
9475 }
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9483 PyObject *obj;
9484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9485 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9486 Py_INCREF(obj);
9487 return Py_BuildValue((char *)"");
9488 }
9489 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj;
9491 wxString *arg1 = 0 ;
9492 wxImage *arg2 = 0 ;
9493 long arg3 ;
9494 bool temp1 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 PyObject * obj2 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "filename",(char *) "image",(char *) "type", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9503 {
9504 arg1 = wxString_in_helper(obj0);
9505 if (arg1 == NULL) SWIG_fail;
9506 temp1 = true;
9507 }
9508 {
9509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9510 if (SWIG_arg_fail(2)) SWIG_fail;
9511 if (arg2 == NULL) {
9512 SWIG_null_ref("wxImage");
9513 }
9514 if (SWIG_arg_fail(2)) SWIG_fail;
9515 }
9516 {
9517 arg3 = (long)(SWIG_As_long(obj2));
9518 if (SWIG_arg_fail(3)) SWIG_fail;
9519 }
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 Py_INCREF(Py_None); resultobj = Py_None;
9528 {
9529 if (temp1)
9530 delete arg1;
9531 }
9532 return resultobj;
9533 fail:
9534 {
9535 if (temp1)
9536 delete arg1;
9537 }
9538 return NULL;
9539 }
9540
9541
9542 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj;
9544 wxString *arg1 = 0 ;
9545 wxBitmap *arg2 = 0 ;
9546 long arg3 ;
9547 bool temp1 = false ;
9548 PyObject * obj0 = 0 ;
9549 PyObject * obj1 = 0 ;
9550 PyObject * obj2 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9556 {
9557 arg1 = wxString_in_helper(obj0);
9558 if (arg1 == NULL) SWIG_fail;
9559 temp1 = true;
9560 }
9561 {
9562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9563 if (SWIG_arg_fail(2)) SWIG_fail;
9564 if (arg2 == NULL) {
9565 SWIG_null_ref("wxBitmap");
9566 }
9567 if (SWIG_arg_fail(2)) SWIG_fail;
9568 }
9569 {
9570 arg3 = (long)(SWIG_As_long(obj2));
9571 if (SWIG_arg_fail(3)) SWIG_fail;
9572 }
9573 {
9574 PyThreadState* __tstate = wxPyBeginAllowThreads();
9575 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9576
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 Py_INCREF(Py_None); resultobj = Py_None;
9581 {
9582 if (temp1)
9583 delete arg1;
9584 }
9585 return resultobj;
9586 fail:
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return NULL;
9592 }
9593
9594
9595 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj;
9597 wxString *arg1 = 0 ;
9598 PyObject *arg2 = (PyObject *) 0 ;
9599 bool temp1 = false ;
9600 PyObject * obj0 = 0 ;
9601 PyObject * obj1 = 0 ;
9602 char *kwnames[] = {
9603 (char *) "filename",(char *) "data", NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9607 {
9608 arg1 = wxString_in_helper(obj0);
9609 if (arg1 == NULL) SWIG_fail;
9610 temp1 = true;
9611 }
9612 arg2 = obj1;
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9616
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 Py_INCREF(Py_None); resultobj = Py_None;
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return resultobj;
9626 fail:
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxMemoryFSHandler *result;
9638 char *kwnames[] = {
9639 NULL
9640 };
9641
9642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9646
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj;
9659 wxString *arg1 = 0 ;
9660 bool temp1 = false ;
9661 PyObject * obj0 = 0 ;
9662 char *kwnames[] = {
9663 (char *) "filename", NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9667 {
9668 arg1 = wxString_in_helper(obj0);
9669 if (arg1 == NULL) SWIG_fail;
9670 temp1 = true;
9671 }
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9675
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 Py_INCREF(Py_None); resultobj = Py_None;
9680 {
9681 if (temp1)
9682 delete arg1;
9683 }
9684 return resultobj;
9685 fail:
9686 {
9687 if (temp1)
9688 delete arg1;
9689 }
9690 return NULL;
9691 }
9692
9693
9694 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj;
9696 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9697 wxString *arg2 = 0 ;
9698 bool result;
9699 bool temp2 = false ;
9700 PyObject * obj0 = 0 ;
9701 PyObject * obj1 = 0 ;
9702 char *kwnames[] = {
9703 (char *) "self",(char *) "location", NULL
9704 };
9705
9706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9708 if (SWIG_arg_fail(1)) SWIG_fail;
9709 {
9710 arg2 = wxString_in_helper(obj1);
9711 if (arg2 == NULL) SWIG_fail;
9712 temp2 = true;
9713 }
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9723 }
9724 {
9725 if (temp2)
9726 delete arg2;
9727 }
9728 return resultobj;
9729 fail:
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9741 wxFileSystem *arg2 = 0 ;
9742 wxString *arg3 = 0 ;
9743 wxFSFile *result;
9744 bool temp3 = false ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 PyObject * obj2 = 0 ;
9748 char *kwnames[] = {
9749 (char *) "self",(char *) "fs",(char *) "location", NULL
9750 };
9751
9752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9754 if (SWIG_arg_fail(1)) SWIG_fail;
9755 {
9756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(2)) SWIG_fail;
9758 if (arg2 == NULL) {
9759 SWIG_null_ref("wxFileSystem");
9760 }
9761 if (SWIG_arg_fail(2)) SWIG_fail;
9762 }
9763 {
9764 arg3 = wxString_in_helper(obj2);
9765 if (arg3 == NULL) SWIG_fail;
9766 temp3 = true;
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 resultobj = wxPyMake_wxObject(result, 1);
9777 }
9778 {
9779 if (temp3)
9780 delete arg3;
9781 }
9782 return resultobj;
9783 fail:
9784 {
9785 if (temp3)
9786 delete arg3;
9787 }
9788 return NULL;
9789 }
9790
9791
9792 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9793 PyObject *resultobj;
9794 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9795 wxString *arg2 = 0 ;
9796 int arg3 = (int) 0 ;
9797 wxString result;
9798 bool temp2 = false ;
9799 PyObject * obj0 = 0 ;
9800 PyObject * obj1 = 0 ;
9801 PyObject * obj2 = 0 ;
9802 char *kwnames[] = {
9803 (char *) "self",(char *) "spec",(char *) "flags", NULL
9804 };
9805
9806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(1)) SWIG_fail;
9809 {
9810 arg2 = wxString_in_helper(obj1);
9811 if (arg2 == NULL) SWIG_fail;
9812 temp2 = true;
9813 }
9814 if (obj2) {
9815 {
9816 arg3 = (int)(SWIG_As_int(obj2));
9817 if (SWIG_arg_fail(3)) SWIG_fail;
9818 }
9819 }
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 {
9828 #if wxUSE_UNICODE
9829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9830 #else
9831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9832 #endif
9833 }
9834 {
9835 if (temp2)
9836 delete arg2;
9837 }
9838 return resultobj;
9839 fail:
9840 {
9841 if (temp2)
9842 delete arg2;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9849 PyObject *resultobj;
9850 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9851 wxString result;
9852 PyObject * obj0 = 0 ;
9853 char *kwnames[] = {
9854 (char *) "self", NULL
9855 };
9856
9857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9859 if (SWIG_arg_fail(1)) SWIG_fail;
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 result = (arg1)->FindNext();
9863
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9872 #endif
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9881 PyObject *obj;
9882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9883 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9884 Py_INCREF(obj);
9885 return Py_BuildValue((char *)"");
9886 }
9887 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9888 PyObject *resultobj;
9889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9890 wxString result;
9891 PyObject * obj0 = 0 ;
9892 char *kwnames[] = {
9893 (char *) "self", NULL
9894 };
9895
9896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9898 if (SWIG_arg_fail(1)) SWIG_fail;
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 result = (arg1)->GetName();
9902
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 {
9907 #if wxUSE_UNICODE
9908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9909 #else
9910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9911 #endif
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9922 wxString result;
9923 PyObject * obj0 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (arg1)->GetExtension();
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 #if wxUSE_UNICODE
9940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9941 #else
9942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9943 #endif
9944 }
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj;
9953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9954 long result;
9955 PyObject * obj0 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (long)(arg1)->GetType();
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 {
9971 resultobj = SWIG_From_long((long)(result));
9972 }
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj;
9981 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9982 wxString result;
9983 PyObject * obj0 = 0 ;
9984 char *kwnames[] = {
9985 (char *) "self", NULL
9986 };
9987
9988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9990 if (SWIG_arg_fail(1)) SWIG_fail;
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 result = (arg1)->GetMimeType();
9994
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 {
9999 #if wxUSE_UNICODE
10000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10001 #else
10002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10003 #endif
10004 }
10005 return resultobj;
10006 fail:
10007 return NULL;
10008 }
10009
10010
10011 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10012 PyObject *resultobj;
10013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10014 wxString *arg2 = 0 ;
10015 bool result;
10016 bool temp2 = false ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 char *kwnames[] = {
10020 (char *) "self",(char *) "name", NULL
10021 };
10022
10023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10025 if (SWIG_arg_fail(1)) SWIG_fail;
10026 {
10027 arg2 = wxString_in_helper(obj1);
10028 if (arg2 == NULL) SWIG_fail;
10029 temp2 = true;
10030 }
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10034
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 {
10039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10040 }
10041 {
10042 if (temp2)
10043 delete arg2;
10044 }
10045 return resultobj;
10046 fail:
10047 {
10048 if (temp2)
10049 delete arg2;
10050 }
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj;
10057 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10058 wxString *arg2 = 0 ;
10059 bool temp2 = false ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char *kwnames[] = {
10063 (char *) "self",(char *) "name", NULL
10064 };
10065
10066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10068 if (SWIG_arg_fail(1)) SWIG_fail;
10069 {
10070 arg2 = wxString_in_helper(obj1);
10071 if (arg2 == NULL) SWIG_fail;
10072 temp2 = true;
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 (arg1)->SetName((wxString const &)*arg2);
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 Py_INCREF(Py_None); resultobj = Py_None;
10082 {
10083 if (temp2)
10084 delete arg2;
10085 }
10086 return resultobj;
10087 fail:
10088 {
10089 if (temp2)
10090 delete arg2;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 bool temp2 = false ;
10101 PyObject * obj0 = 0 ;
10102 PyObject * obj1 = 0 ;
10103 char *kwnames[] = {
10104 (char *) "self",(char *) "extension", NULL
10105 };
10106
10107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10109 if (SWIG_arg_fail(1)) SWIG_fail;
10110 {
10111 arg2 = wxString_in_helper(obj1);
10112 if (arg2 == NULL) SWIG_fail;
10113 temp2 = true;
10114 }
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->SetExtension((wxString const &)*arg2);
10118
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 Py_INCREF(Py_None); resultobj = Py_None;
10123 {
10124 if (temp2)
10125 delete arg2;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp2)
10131 delete arg2;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj;
10139 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10140 long arg2 ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "self",(char *) "type", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10149 if (SWIG_arg_fail(1)) SWIG_fail;
10150 {
10151 arg2 = (long)(SWIG_As_long(obj1));
10152 if (SWIG_arg_fail(2)) SWIG_fail;
10153 }
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 (arg1)->SetType(arg2);
10157
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 Py_INCREF(Py_None); resultobj = Py_None;
10162 return resultobj;
10163 fail:
10164 return NULL;
10165 }
10166
10167
10168 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10169 PyObject *resultobj;
10170 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10171 wxString *arg2 = 0 ;
10172 bool temp2 = false ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "self",(char *) "mimetype", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10181 if (SWIG_arg_fail(1)) SWIG_fail;
10182 {
10183 arg2 = wxString_in_helper(obj1);
10184 if (arg2 == NULL) SWIG_fail;
10185 temp2 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 (arg1)->SetMimeType((wxString const &)*arg2);
10190
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 Py_INCREF(Py_None); resultobj = Py_None;
10195 {
10196 if (temp2)
10197 delete arg2;
10198 }
10199 return resultobj;
10200 fail:
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return NULL;
10206 }
10207
10208
10209 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10210 PyObject *obj;
10211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10212 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10213 Py_INCREF(obj);
10214 return Py_BuildValue((char *)"");
10215 }
10216 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj;
10218 wxImageHistogram *result;
10219 char *kwnames[] = {
10220 NULL
10221 };
10222
10223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (wxImageHistogram *)new wxImageHistogram();
10227
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj;
10240 unsigned char arg1 ;
10241 unsigned char arg2 ;
10242 unsigned char arg3 ;
10243 unsigned long result;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 PyObject * obj2 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "r",(char *) "g",(char *) "b", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10252 {
10253 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 }
10256 {
10257 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10258 if (SWIG_arg_fail(2)) SWIG_fail;
10259 }
10260 {
10261 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10262 if (SWIG_arg_fail(3)) SWIG_fail;
10263 }
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10267
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 {
10272 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10273 }
10274 return resultobj;
10275 fail:
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj;
10282 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10283 unsigned char *arg2 = (unsigned char *) 0 ;
10284 unsigned char *arg3 = (unsigned char *) 0 ;
10285 unsigned char *arg4 = (unsigned char *) 0 ;
10286 unsigned char arg5 = (unsigned char) 1 ;
10287 unsigned char arg6 = (unsigned char) 0 ;
10288 unsigned char arg7 = (unsigned char) 0 ;
10289 bool result;
10290 unsigned char temp2 ;
10291 int res2 = 0 ;
10292 unsigned char temp3 ;
10293 int res3 = 0 ;
10294 unsigned char temp4 ;
10295 int res4 = 0 ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 PyObject * obj2 = 0 ;
10299 PyObject * obj3 = 0 ;
10300 char *kwnames[] = {
10301 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10302 };
10303
10304 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10305 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10306 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 if (obj1) {
10311 {
10312 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10313 if (SWIG_arg_fail(5)) SWIG_fail;
10314 }
10315 }
10316 if (obj2) {
10317 {
10318 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10319 if (SWIG_arg_fail(6)) SWIG_fail;
10320 }
10321 }
10322 if (obj3) {
10323 {
10324 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10325 if (SWIG_arg_fail(7)) SWIG_fail;
10326 }
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 {
10336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10337 }
10338 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10339 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10340 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10341 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10342 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10343 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10353 unsigned long arg2 ;
10354 unsigned long result;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "self",(char *) "key", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 {
10365 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10366 if (SWIG_arg_fail(2)) SWIG_fail;
10367 }
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10371
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 {
10376 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10377 }
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj;
10386 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10387 unsigned char arg2 ;
10388 unsigned char arg3 ;
10389 unsigned char arg4 ;
10390 unsigned long result;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 PyObject * obj2 = 0 ;
10394 PyObject * obj3 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10401 if (SWIG_arg_fail(1)) SWIG_fail;
10402 {
10403 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10404 if (SWIG_arg_fail(2)) SWIG_fail;
10405 }
10406 {
10407 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10408 if (SWIG_arg_fail(3)) SWIG_fail;
10409 }
10410 {
10411 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10412 if (SWIG_arg_fail(4)) SWIG_fail;
10413 }
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10423 }
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj;
10432 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10433 wxColour *arg2 = 0 ;
10434 unsigned long result;
10435 wxColour temp2 ;
10436 PyObject * obj0 = 0 ;
10437 PyObject * obj1 = 0 ;
10438 char *kwnames[] = {
10439 (char *) "self",(char *) "colour", NULL
10440 };
10441
10442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10444 if (SWIG_arg_fail(1)) SWIG_fail;
10445 {
10446 arg2 = &temp2;
10447 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10452
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 {
10457 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10458 }
10459 return resultobj;
10460 fail:
10461 return NULL;
10462 }
10463
10464
10465 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10466 PyObject *obj;
10467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10468 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10469 Py_INCREF(obj);
10470 return Py_BuildValue((char *)"");
10471 }
10472 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj;
10474 wxString *arg1 = 0 ;
10475 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10476 int arg3 = (int) -1 ;
10477 wxImage *result;
10478 bool temp1 = false ;
10479 PyObject * obj0 = 0 ;
10480 PyObject * obj1 = 0 ;
10481 PyObject * obj2 = 0 ;
10482 char *kwnames[] = {
10483 (char *) "name",(char *) "type",(char *) "index", NULL
10484 };
10485
10486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10487 {
10488 arg1 = wxString_in_helper(obj0);
10489 if (arg1 == NULL) SWIG_fail;
10490 temp1 = true;
10491 }
10492 if (obj1) {
10493 {
10494 arg2 = (long)(SWIG_As_long(obj1));
10495 if (SWIG_arg_fail(2)) SWIG_fail;
10496 }
10497 }
10498 if (obj2) {
10499 {
10500 arg3 = (int)(SWIG_As_int(obj2));
10501 if (SWIG_arg_fail(3)) SWIG_fail;
10502 }
10503 }
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10512 {
10513 if (temp1)
10514 delete arg1;
10515 }
10516 return resultobj;
10517 fail:
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 return NULL;
10523 }
10524
10525
10526 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10527 PyObject *resultobj;
10528 wxImage *arg1 = (wxImage *) 0 ;
10529 PyObject * obj0 = 0 ;
10530 char *kwnames[] = {
10531 (char *) "self", NULL
10532 };
10533
10534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10536 if (SWIG_arg_fail(1)) SWIG_fail;
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 delete arg1;
10540
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 Py_INCREF(Py_None); resultobj = Py_None;
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj;
10553 wxString *arg1 = 0 ;
10554 wxString *arg2 = 0 ;
10555 int arg3 = (int) -1 ;
10556 wxImage *result;
10557 bool temp1 = false ;
10558 bool temp2 = false ;
10559 PyObject * obj0 = 0 ;
10560 PyObject * obj1 = 0 ;
10561 PyObject * obj2 = 0 ;
10562 char *kwnames[] = {
10563 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10564 };
10565
10566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10567 {
10568 arg1 = wxString_in_helper(obj0);
10569 if (arg1 == NULL) SWIG_fail;
10570 temp1 = true;
10571 }
10572 {
10573 arg2 = wxString_in_helper(obj1);
10574 if (arg2 == NULL) SWIG_fail;
10575 temp2 = true;
10576 }
10577 if (obj2) {
10578 {
10579 arg3 = (int)(SWIG_As_int(obj2));
10580 if (SWIG_arg_fail(3)) SWIG_fail;
10581 }
10582 }
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10586
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10591 {
10592 if (temp1)
10593 delete arg1;
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj;
10615 wxInputStream *arg1 = 0 ;
10616 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10617 int arg3 = (int) -1 ;
10618 wxImage *result;
10619 wxPyInputStream *temp1 ;
10620 bool created1 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 PyObject * obj2 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "stream",(char *) "type",(char *) "index", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10629 {
10630 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10631 arg1 = temp1->m_wxis;
10632 created1 = false;
10633 } else {
10634 PyErr_Clear(); // clear the failure of the wxPyConvert above
10635 arg1 = wxPyCBInputStream_create(obj0, false);
10636 if (arg1 == NULL) {
10637 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10638 SWIG_fail;
10639 }
10640 created1 = true;
10641 }
10642 }
10643 if (obj1) {
10644 {
10645 arg2 = (long)(SWIG_As_long(obj1));
10646 if (SWIG_arg_fail(2)) SWIG_fail;
10647 }
10648 }
10649 if (obj2) {
10650 {
10651 arg3 = (int)(SWIG_As_int(obj2));
10652 if (SWIG_arg_fail(3)) SWIG_fail;
10653 }
10654 }
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10658
10659 wxPyEndAllowThreads(__tstate);
10660 if (PyErr_Occurred()) SWIG_fail;
10661 }
10662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10663 {
10664 if (created1) delete arg1;
10665 }
10666 return resultobj;
10667 fail:
10668 {
10669 if (created1) delete arg1;
10670 }
10671 return NULL;
10672 }
10673
10674
10675 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj;
10677 wxInputStream *arg1 = 0 ;
10678 wxString *arg2 = 0 ;
10679 int arg3 = (int) -1 ;
10680 wxImage *result;
10681 wxPyInputStream *temp1 ;
10682 bool created1 ;
10683 bool temp2 = false ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 PyObject * obj2 = 0 ;
10687 char *kwnames[] = {
10688 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10689 };
10690
10691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10692 {
10693 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10694 arg1 = temp1->m_wxis;
10695 created1 = false;
10696 } else {
10697 PyErr_Clear(); // clear the failure of the wxPyConvert above
10698 arg1 = wxPyCBInputStream_create(obj0, false);
10699 if (arg1 == NULL) {
10700 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10701 SWIG_fail;
10702 }
10703 created1 = true;
10704 }
10705 }
10706 {
10707 arg2 = wxString_in_helper(obj1);
10708 if (arg2 == NULL) SWIG_fail;
10709 temp2 = true;
10710 }
10711 if (obj2) {
10712 {
10713 arg3 = (int)(SWIG_As_int(obj2));
10714 if (SWIG_arg_fail(3)) SWIG_fail;
10715 }
10716 }
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10725 {
10726 if (created1) delete arg1;
10727 }
10728 {
10729 if (temp2)
10730 delete arg2;
10731 }
10732 return resultobj;
10733 fail:
10734 {
10735 if (created1) delete arg1;
10736 }
10737 {
10738 if (temp2)
10739 delete arg2;
10740 }
10741 return NULL;
10742 }
10743
10744
10745 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj;
10747 int arg1 = (int) 0 ;
10748 int arg2 = (int) 0 ;
10749 bool arg3 = (bool) true ;
10750 wxImage *result;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 PyObject * obj2 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "width",(char *) "height",(char *) "clear", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10759 if (obj0) {
10760 {
10761 arg1 = (int)(SWIG_As_int(obj0));
10762 if (SWIG_arg_fail(1)) SWIG_fail;
10763 }
10764 }
10765 if (obj1) {
10766 {
10767 arg2 = (int)(SWIG_As_int(obj1));
10768 if (SWIG_arg_fail(2)) SWIG_fail;
10769 }
10770 }
10771 if (obj2) {
10772 {
10773 arg3 = (bool)(SWIG_As_bool(obj2));
10774 if (SWIG_arg_fail(3)) SWIG_fail;
10775 }
10776 }
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj;
10793 wxBitmap *arg1 = 0 ;
10794 wxImage *result;
10795 PyObject * obj0 = 0 ;
10796 char *kwnames[] = {
10797 (char *) "bitmap", NULL
10798 };
10799
10800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10801 {
10802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10803 if (SWIG_arg_fail(1)) SWIG_fail;
10804 if (arg1 == NULL) {
10805 SWIG_null_ref("wxBitmap");
10806 }
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 }
10809 {
10810 if (!wxPyCheckForApp()) SWIG_fail;
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10813
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10825 PyObject *resultobj;
10826 int arg1 ;
10827 int arg2 ;
10828 buffer arg3 ;
10829 int arg4 ;
10830 wxImage *result;
10831 PyObject * obj0 = 0 ;
10832 PyObject * obj1 = 0 ;
10833 PyObject * obj2 = 0 ;
10834 char *kwnames[] = {
10835 (char *) "width",(char *) "height",(char *) "data", NULL
10836 };
10837
10838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10839 {
10840 arg1 = (int)(SWIG_As_int(obj0));
10841 if (SWIG_arg_fail(1)) SWIG_fail;
10842 }
10843 {
10844 arg2 = (int)(SWIG_As_int(obj1));
10845 if (SWIG_arg_fail(2)) SWIG_fail;
10846 }
10847 {
10848 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10849 }
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10853
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 int arg1 ;
10867 int arg2 ;
10868 buffer arg3 ;
10869 int arg4 ;
10870 buffer arg5 ;
10871 int arg6 ;
10872 wxImage *result;
10873 PyObject * obj0 = 0 ;
10874 PyObject * obj1 = 0 ;
10875 PyObject * obj2 = 0 ;
10876 PyObject * obj3 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10882 {
10883 arg1 = (int)(SWIG_As_int(obj0));
10884 if (SWIG_arg_fail(1)) SWIG_fail;
10885 }
10886 {
10887 arg2 = (int)(SWIG_As_int(obj1));
10888 if (SWIG_arg_fail(2)) SWIG_fail;
10889 }
10890 {
10891 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10892 }
10893 {
10894 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10895 }
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10899
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj;
10912 wxImage *arg1 = (wxImage *) 0 ;
10913 int arg2 ;
10914 int arg3 ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 PyObject * obj2 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self",(char *) "width",(char *) "height", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 arg2 = (int)(SWIG_As_int(obj1));
10927 if (SWIG_arg_fail(2)) SWIG_fail;
10928 }
10929 {
10930 arg3 = (int)(SWIG_As_int(obj2));
10931 if (SWIG_arg_fail(3)) SWIG_fail;
10932 }
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 (arg1)->Create(arg2,arg3);
10936
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 Py_INCREF(Py_None); resultobj = Py_None;
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj;
10949 wxImage *arg1 = (wxImage *) 0 ;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 (arg1)->Destroy();
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 Py_INCREF(Py_None); resultobj = Py_None;
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10973 PyObject *resultobj;
10974 wxImage *arg1 = (wxImage *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 SwigValueWrapper<wxImage > result;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 PyObject * obj2 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "width",(char *) "height", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 {
10993 arg3 = (int)(SWIG_As_int(obj2));
10994 if (SWIG_arg_fail(3)) SWIG_fail;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (arg1)->Scale(arg2,arg3);
10999
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 wxImage * resultptr;
11005 resultptr = new wxImage((wxImage &)(result));
11006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxImage *arg1 = (wxImage *) 0 ;
11017 int arg2 ;
11018 int arg3 ;
11019 SwigValueWrapper<wxImage > result;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 PyObject * obj2 = 0 ;
11023 char *kwnames[] = {
11024 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11025 };
11026
11027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11029 if (SWIG_arg_fail(1)) SWIG_fail;
11030 {
11031 arg2 = (int)(SWIG_As_int(obj1));
11032 if (SWIG_arg_fail(2)) SWIG_fail;
11033 }
11034 {
11035 arg3 = (int)(SWIG_As_int(obj2));
11036 if (SWIG_arg_fail(3)) SWIG_fail;
11037 }
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 wxImage * resultptr;
11047 resultptr = new wxImage((wxImage &)(result));
11048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxImage *arg1 = (wxImage *) 0 ;
11059 int arg2 ;
11060 int arg3 ;
11061 wxImage *result;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 PyObject * obj2 = 0 ;
11065 char *kwnames[] = {
11066 (char *) "self",(char *) "width",(char *) "height", NULL
11067 };
11068
11069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11071 if (SWIG_arg_fail(1)) SWIG_fail;
11072 {
11073 arg2 = (int)(SWIG_As_int(obj1));
11074 if (SWIG_arg_fail(2)) SWIG_fail;
11075 }
11076 {
11077 arg3 = (int)(SWIG_As_int(obj2));
11078 if (SWIG_arg_fail(3)) SWIG_fail;
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 {
11083 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11084 result = (wxImage *) &_result_ref;
11085 }
11086
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj;
11099 wxImage *arg1 = (wxImage *) 0 ;
11100 wxSize *arg2 = 0 ;
11101 wxPoint *arg3 = 0 ;
11102 int arg4 = (int) -1 ;
11103 int arg5 = (int) -1 ;
11104 int arg6 = (int) -1 ;
11105 wxImage *result;
11106 wxSize temp2 ;
11107 wxPoint temp3 ;
11108 PyObject * obj0 = 0 ;
11109 PyObject * obj1 = 0 ;
11110 PyObject * obj2 = 0 ;
11111 PyObject * obj3 = 0 ;
11112 PyObject * obj4 = 0 ;
11113 PyObject * obj5 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 arg2 = &temp2;
11123 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11124 }
11125 {
11126 arg3 = &temp3;
11127 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11128 }
11129 if (obj3) {
11130 {
11131 arg4 = (int)(SWIG_As_int(obj3));
11132 if (SWIG_arg_fail(4)) SWIG_fail;
11133 }
11134 }
11135 if (obj4) {
11136 {
11137 arg5 = (int)(SWIG_As_int(obj4));
11138 if (SWIG_arg_fail(5)) SWIG_fail;
11139 }
11140 }
11141 if (obj5) {
11142 {
11143 arg6 = (int)(SWIG_As_int(obj5));
11144 if (SWIG_arg_fail(6)) SWIG_fail;
11145 }
11146 }
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 {
11150 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11151 result = (wxImage *) &_result_ref;
11152 }
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxImage *arg1 = (wxImage *) 0 ;
11167 int arg2 ;
11168 int arg3 ;
11169 unsigned char arg4 ;
11170 unsigned char arg5 ;
11171 unsigned char arg6 ;
11172 PyObject * obj0 = 0 ;
11173 PyObject * obj1 = 0 ;
11174 PyObject * obj2 = 0 ;
11175 PyObject * obj3 = 0 ;
11176 PyObject * obj4 = 0 ;
11177 PyObject * obj5 = 0 ;
11178 char *kwnames[] = {
11179 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11180 };
11181
11182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11184 if (SWIG_arg_fail(1)) SWIG_fail;
11185 {
11186 arg2 = (int)(SWIG_As_int(obj1));
11187 if (SWIG_arg_fail(2)) SWIG_fail;
11188 }
11189 {
11190 arg3 = (int)(SWIG_As_int(obj2));
11191 if (SWIG_arg_fail(3)) SWIG_fail;
11192 }
11193 {
11194 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11195 if (SWIG_arg_fail(4)) SWIG_fail;
11196 }
11197 {
11198 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11199 if (SWIG_arg_fail(5)) SWIG_fail;
11200 }
11201 {
11202 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11203 if (SWIG_arg_fail(6)) SWIG_fail;
11204 }
11205 {
11206 PyThreadState* __tstate = wxPyBeginAllowThreads();
11207 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11208
11209 wxPyEndAllowThreads(__tstate);
11210 if (PyErr_Occurred()) SWIG_fail;
11211 }
11212 Py_INCREF(Py_None); resultobj = Py_None;
11213 return resultobj;
11214 fail:
11215 return NULL;
11216 }
11217
11218
11219 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11220 PyObject *resultobj;
11221 wxImage *arg1 = (wxImage *) 0 ;
11222 wxRect *arg2 = 0 ;
11223 unsigned char arg3 ;
11224 unsigned char arg4 ;
11225 unsigned char arg5 ;
11226 wxRect temp2 ;
11227 PyObject * obj0 = 0 ;
11228 PyObject * obj1 = 0 ;
11229 PyObject * obj2 = 0 ;
11230 PyObject * obj3 = 0 ;
11231 PyObject * obj4 = 0 ;
11232 char *kwnames[] = {
11233 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11234 };
11235
11236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11238 if (SWIG_arg_fail(1)) SWIG_fail;
11239 {
11240 arg2 = &temp2;
11241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11242 }
11243 {
11244 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11245 if (SWIG_arg_fail(3)) SWIG_fail;
11246 }
11247 {
11248 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11249 if (SWIG_arg_fail(4)) SWIG_fail;
11250 }
11251 {
11252 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11253 if (SWIG_arg_fail(5)) SWIG_fail;
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11258
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 Py_INCREF(Py_None); resultobj = Py_None;
11263 return resultobj;
11264 fail:
11265 return NULL;
11266 }
11267
11268
11269 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11270 PyObject *resultobj;
11271 wxImage *arg1 = (wxImage *) 0 ;
11272 int arg2 ;
11273 int arg3 ;
11274 unsigned char result;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 char *kwnames[] = {
11279 (char *) "self",(char *) "x",(char *) "y", NULL
11280 };
11281
11282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11284 if (SWIG_arg_fail(1)) SWIG_fail;
11285 {
11286 arg2 = (int)(SWIG_As_int(obj1));
11287 if (SWIG_arg_fail(2)) SWIG_fail;
11288 }
11289 {
11290 arg3 = (int)(SWIG_As_int(obj2));
11291 if (SWIG_arg_fail(3)) SWIG_fail;
11292 }
11293 {
11294 PyThreadState* __tstate = wxPyBeginAllowThreads();
11295 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11296
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 {
11301 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxImage *arg1 = (wxImage *) 0 ;
11312 int arg2 ;
11313 int arg3 ;
11314 unsigned char result;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 PyObject * obj2 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "self",(char *) "x",(char *) "y", NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 {
11326 arg2 = (int)(SWIG_As_int(obj1));
11327 if (SWIG_arg_fail(2)) SWIG_fail;
11328 }
11329 {
11330 arg3 = (int)(SWIG_As_int(obj2));
11331 if (SWIG_arg_fail(3)) SWIG_fail;
11332 }
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11336
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 {
11341 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11342 }
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11350 PyObject *resultobj;
11351 wxImage *arg1 = (wxImage *) 0 ;
11352 int arg2 ;
11353 int arg3 ;
11354 unsigned char result;
11355 PyObject * obj0 = 0 ;
11356 PyObject * obj1 = 0 ;
11357 PyObject * obj2 = 0 ;
11358 char *kwnames[] = {
11359 (char *) "self",(char *) "x",(char *) "y", NULL
11360 };
11361
11362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 {
11366 arg2 = (int)(SWIG_As_int(obj1));
11367 if (SWIG_arg_fail(2)) SWIG_fail;
11368 }
11369 {
11370 arg3 = (int)(SWIG_As_int(obj2));
11371 if (SWIG_arg_fail(3)) SWIG_fail;
11372 }
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11376
11377 wxPyEndAllowThreads(__tstate);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 {
11381 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11382 }
11383 return resultobj;
11384 fail:
11385 return NULL;
11386 }
11387
11388
11389 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11390 PyObject *resultobj;
11391 wxImage *arg1 = (wxImage *) 0 ;
11392 int arg2 ;
11393 int arg3 ;
11394 unsigned char arg4 ;
11395 PyObject * obj0 = 0 ;
11396 PyObject * obj1 = 0 ;
11397 PyObject * obj2 = 0 ;
11398 PyObject * obj3 = 0 ;
11399 char *kwnames[] = {
11400 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11401 };
11402
11403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11405 if (SWIG_arg_fail(1)) SWIG_fail;
11406 {
11407 arg2 = (int)(SWIG_As_int(obj1));
11408 if (SWIG_arg_fail(2)) SWIG_fail;
11409 }
11410 {
11411 arg3 = (int)(SWIG_As_int(obj2));
11412 if (SWIG_arg_fail(3)) SWIG_fail;
11413 }
11414 {
11415 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11416 if (SWIG_arg_fail(4)) SWIG_fail;
11417 }
11418 {
11419 PyThreadState* __tstate = wxPyBeginAllowThreads();
11420 (arg1)->SetAlpha(arg2,arg3,arg4);
11421
11422 wxPyEndAllowThreads(__tstate);
11423 if (PyErr_Occurred()) SWIG_fail;
11424 }
11425 Py_INCREF(Py_None); resultobj = Py_None;
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj;
11434 wxImage *arg1 = (wxImage *) 0 ;
11435 int arg2 ;
11436 int arg3 ;
11437 unsigned char result;
11438 PyObject * obj0 = 0 ;
11439 PyObject * obj1 = 0 ;
11440 PyObject * obj2 = 0 ;
11441 char *kwnames[] = {
11442 (char *) "self",(char *) "x",(char *) "y", NULL
11443 };
11444
11445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11447 if (SWIG_arg_fail(1)) SWIG_fail;
11448 {
11449 arg2 = (int)(SWIG_As_int(obj1));
11450 if (SWIG_arg_fail(2)) SWIG_fail;
11451 }
11452 {
11453 arg3 = (int)(SWIG_As_int(obj2));
11454 if (SWIG_arg_fail(3)) SWIG_fail;
11455 }
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11459
11460 wxPyEndAllowThreads(__tstate);
11461 if (PyErr_Occurred()) SWIG_fail;
11462 }
11463 {
11464 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11465 }
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj;
11474 wxImage *arg1 = (wxImage *) 0 ;
11475 bool result;
11476 PyObject * obj0 = 0 ;
11477 char *kwnames[] = {
11478 (char *) "self", NULL
11479 };
11480
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11483 if (SWIG_arg_fail(1)) SWIG_fail;
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (bool)(arg1)->HasAlpha();
11487
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11493 }
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj;
11502 wxImage *arg1 = (wxImage *) 0 ;
11503 PyObject * obj0 = 0 ;
11504 char *kwnames[] = {
11505 (char *) "self", NULL
11506 };
11507
11508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11510 if (SWIG_arg_fail(1)) SWIG_fail;
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 (arg1)->InitAlpha();
11514
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 Py_INCREF(Py_None); resultobj = Py_None;
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 wxImage *arg1 = (wxImage *) 0 ;
11528 byte *arg2 = (byte *) 0 ;
11529 byte *arg3 = (byte *) 0 ;
11530 byte *arg4 = (byte *) 0 ;
11531 byte arg5 = (byte) 0 ;
11532 byte arg6 = (byte) 0 ;
11533 byte arg7 = (byte) 0 ;
11534 bool result;
11535 byte temp2 ;
11536 int res2 = 0 ;
11537 byte temp3 ;
11538 int res3 = 0 ;
11539 byte temp4 ;
11540 int res4 = 0 ;
11541 PyObject * obj0 = 0 ;
11542 PyObject * obj1 = 0 ;
11543 PyObject * obj2 = 0 ;
11544 PyObject * obj3 = 0 ;
11545 char *kwnames[] = {
11546 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11547 };
11548
11549 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11550 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11551 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11554 if (SWIG_arg_fail(1)) SWIG_fail;
11555 if (obj1) {
11556 {
11557 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11558 if (SWIG_arg_fail(5)) SWIG_fail;
11559 }
11560 }
11561 if (obj2) {
11562 {
11563 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11564 if (SWIG_arg_fail(6)) SWIG_fail;
11565 }
11566 }
11567 if (obj3) {
11568 {
11569 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11570 if (SWIG_arg_fail(7)) SWIG_fail;
11571 }
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11576
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 {
11581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11582 }
11583 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11584 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11585 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11586 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11587 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11588 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11589 return resultobj;
11590 fail:
11591 return NULL;
11592 }
11593
11594
11595 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11596 PyObject *resultobj;
11597 wxImage *arg1 = (wxImage *) 0 ;
11598 byte arg2 = (byte) 128 ;
11599 bool result;
11600 PyObject * obj0 = 0 ;
11601 PyObject * obj1 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "self",(char *) "threshold", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11608 if (SWIG_arg_fail(1)) SWIG_fail;
11609 if (obj1) {
11610 {
11611 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11612 if (SWIG_arg_fail(2)) SWIG_fail;
11613 }
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11618
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 {
11623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11624 }
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj;
11633 wxImage *arg1 = (wxImage *) 0 ;
11634 unsigned char arg2 ;
11635 unsigned char arg3 ;
11636 unsigned char arg4 ;
11637 bool result;
11638 PyObject * obj0 = 0 ;
11639 PyObject * obj1 = 0 ;
11640 PyObject * obj2 = 0 ;
11641 PyObject * obj3 = 0 ;
11642 char *kwnames[] = {
11643 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11644 };
11645
11646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11648 if (SWIG_arg_fail(1)) SWIG_fail;
11649 {
11650 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11651 if (SWIG_arg_fail(2)) SWIG_fail;
11652 }
11653 {
11654 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11655 if (SWIG_arg_fail(3)) SWIG_fail;
11656 }
11657 {
11658 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11659 if (SWIG_arg_fail(4)) SWIG_fail;
11660 }
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11664
11665 wxPyEndAllowThreads(__tstate);
11666 if (PyErr_Occurred()) SWIG_fail;
11667 }
11668 {
11669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11670 }
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj;
11679 wxImage *arg1 = (wxImage *) 0 ;
11680 wxImage *arg2 = 0 ;
11681 byte arg3 ;
11682 byte arg4 ;
11683 byte arg5 ;
11684 bool result;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 PyObject * obj3 = 0 ;
11689 PyObject * obj4 = 0 ;
11690 char *kwnames[] = {
11691 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11692 };
11693
11694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11696 if (SWIG_arg_fail(1)) SWIG_fail;
11697 {
11698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(2)) SWIG_fail;
11700 if (arg2 == NULL) {
11701 SWIG_null_ref("wxImage");
11702 }
11703 if (SWIG_arg_fail(2)) SWIG_fail;
11704 }
11705 {
11706 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11707 if (SWIG_arg_fail(3)) SWIG_fail;
11708 }
11709 {
11710 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11711 if (SWIG_arg_fail(4)) SWIG_fail;
11712 }
11713 {
11714 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11715 if (SWIG_arg_fail(5)) SWIG_fail;
11716 }
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11720
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 {
11725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11726 }
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj;
11735 wxString *arg1 = 0 ;
11736 bool result;
11737 bool temp1 = false ;
11738 PyObject * obj0 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "name", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11744 {
11745 arg1 = wxString_in_helper(obj0);
11746 if (arg1 == NULL) SWIG_fail;
11747 temp1 = true;
11748 }
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11752
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 {
11757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11758 }
11759 {
11760 if (temp1)
11761 delete arg1;
11762 }
11763 return resultobj;
11764 fail:
11765 {
11766 if (temp1)
11767 delete arg1;
11768 }
11769 return NULL;
11770 }
11771
11772
11773 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxString *arg1 = 0 ;
11776 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11777 int result;
11778 bool temp1 = false ;
11779 PyObject * obj0 = 0 ;
11780 PyObject * obj1 = 0 ;
11781 char *kwnames[] = {
11782 (char *) "name",(char *) "type", NULL
11783 };
11784
11785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11786 {
11787 arg1 = wxString_in_helper(obj0);
11788 if (arg1 == NULL) SWIG_fail;
11789 temp1 = true;
11790 }
11791 if (obj1) {
11792 {
11793 arg2 = (long)(SWIG_As_long(obj1));
11794 if (SWIG_arg_fail(2)) SWIG_fail;
11795 }
11796 }
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11800
11801 wxPyEndAllowThreads(__tstate);
11802 if (PyErr_Occurred()) SWIG_fail;
11803 }
11804 {
11805 resultobj = SWIG_From_int((int)(result));
11806 }
11807 {
11808 if (temp1)
11809 delete arg1;
11810 }
11811 return resultobj;
11812 fail:
11813 {
11814 if (temp1)
11815 delete arg1;
11816 }
11817 return NULL;
11818 }
11819
11820
11821 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11822 PyObject *resultobj;
11823 wxImage *arg1 = (wxImage *) 0 ;
11824 wxString *arg2 = 0 ;
11825 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11826 int arg4 = (int) -1 ;
11827 bool result;
11828 bool temp2 = false ;
11829 PyObject * obj0 = 0 ;
11830 PyObject * obj1 = 0 ;
11831 PyObject * obj2 = 0 ;
11832 PyObject * obj3 = 0 ;
11833 char *kwnames[] = {
11834 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11835 };
11836
11837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11839 if (SWIG_arg_fail(1)) SWIG_fail;
11840 {
11841 arg2 = wxString_in_helper(obj1);
11842 if (arg2 == NULL) SWIG_fail;
11843 temp2 = true;
11844 }
11845 if (obj2) {
11846 {
11847 arg3 = (long)(SWIG_As_long(obj2));
11848 if (SWIG_arg_fail(3)) SWIG_fail;
11849 }
11850 }
11851 if (obj3) {
11852 {
11853 arg4 = (int)(SWIG_As_int(obj3));
11854 if (SWIG_arg_fail(4)) SWIG_fail;
11855 }
11856 }
11857 {
11858 PyThreadState* __tstate = wxPyBeginAllowThreads();
11859 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11860
11861 wxPyEndAllowThreads(__tstate);
11862 if (PyErr_Occurred()) SWIG_fail;
11863 }
11864 {
11865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11866 }
11867 {
11868 if (temp2)
11869 delete arg2;
11870 }
11871 return resultobj;
11872 fail:
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return NULL;
11878 }
11879
11880
11881 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11882 PyObject *resultobj;
11883 wxImage *arg1 = (wxImage *) 0 ;
11884 wxString *arg2 = 0 ;
11885 wxString *arg3 = 0 ;
11886 int arg4 = (int) -1 ;
11887 bool result;
11888 bool temp2 = false ;
11889 bool temp3 = false ;
11890 PyObject * obj0 = 0 ;
11891 PyObject * obj1 = 0 ;
11892 PyObject * obj2 = 0 ;
11893 PyObject * obj3 = 0 ;
11894 char *kwnames[] = {
11895 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11896 };
11897
11898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11900 if (SWIG_arg_fail(1)) SWIG_fail;
11901 {
11902 arg2 = wxString_in_helper(obj1);
11903 if (arg2 == NULL) SWIG_fail;
11904 temp2 = true;
11905 }
11906 {
11907 arg3 = wxString_in_helper(obj2);
11908 if (arg3 == NULL) SWIG_fail;
11909 temp3 = true;
11910 }
11911 if (obj3) {
11912 {
11913 arg4 = (int)(SWIG_As_int(obj3));
11914 if (SWIG_arg_fail(4)) SWIG_fail;
11915 }
11916 }
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11920
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 {
11925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11926 }
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 {
11932 if (temp3)
11933 delete arg3;
11934 }
11935 return resultobj;
11936 fail:
11937 {
11938 if (temp2)
11939 delete arg2;
11940 }
11941 {
11942 if (temp3)
11943 delete arg3;
11944 }
11945 return NULL;
11946 }
11947
11948
11949 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj;
11951 wxImage *arg1 = (wxImage *) 0 ;
11952 wxString *arg2 = 0 ;
11953 int arg3 ;
11954 bool result;
11955 bool temp2 = false ;
11956 PyObject * obj0 = 0 ;
11957 PyObject * obj1 = 0 ;
11958 PyObject * obj2 = 0 ;
11959 char *kwnames[] = {
11960 (char *) "self",(char *) "name",(char *) "type", NULL
11961 };
11962
11963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11965 if (SWIG_arg_fail(1)) SWIG_fail;
11966 {
11967 arg2 = wxString_in_helper(obj1);
11968 if (arg2 == NULL) SWIG_fail;
11969 temp2 = true;
11970 }
11971 {
11972 arg3 = (int)(SWIG_As_int(obj2));
11973 if (SWIG_arg_fail(3)) SWIG_fail;
11974 }
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11984 }
11985 {
11986 if (temp2)
11987 delete arg2;
11988 }
11989 return resultobj;
11990 fail:
11991 {
11992 if (temp2)
11993 delete arg2;
11994 }
11995 return NULL;
11996 }
11997
11998
11999 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj;
12001 wxImage *arg1 = (wxImage *) 0 ;
12002 wxString *arg2 = 0 ;
12003 wxString *arg3 = 0 ;
12004 bool result;
12005 bool temp2 = false ;
12006 bool temp3 = false ;
12007 PyObject * obj0 = 0 ;
12008 PyObject * obj1 = 0 ;
12009 PyObject * obj2 = 0 ;
12010 char *kwnames[] = {
12011 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12012 };
12013
12014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12016 if (SWIG_arg_fail(1)) SWIG_fail;
12017 {
12018 arg2 = wxString_in_helper(obj1);
12019 if (arg2 == NULL) SWIG_fail;
12020 temp2 = true;
12021 }
12022 {
12023 arg3 = wxString_in_helper(obj2);
12024 if (arg3 == NULL) SWIG_fail;
12025 temp3 = true;
12026 }
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12030
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 {
12035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12036 }
12037 {
12038 if (temp2)
12039 delete arg2;
12040 }
12041 {
12042 if (temp3)
12043 delete arg3;
12044 }
12045 return resultobj;
12046 fail:
12047 {
12048 if (temp2)
12049 delete arg2;
12050 }
12051 {
12052 if (temp3)
12053 delete arg3;
12054 }
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxInputStream *arg1 = 0 ;
12062 bool result;
12063 wxPyInputStream *temp1 ;
12064 bool created1 ;
12065 PyObject * obj0 = 0 ;
12066 char *kwnames[] = {
12067 (char *) "stream", NULL
12068 };
12069
12070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12071 {
12072 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12073 arg1 = temp1->m_wxis;
12074 created1 = false;
12075 } else {
12076 PyErr_Clear(); // clear the failure of the wxPyConvert above
12077 arg1 = wxPyCBInputStream_create(obj0, false);
12078 if (arg1 == NULL) {
12079 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12080 SWIG_fail;
12081 }
12082 created1 = true;
12083 }
12084 }
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 result = (bool)wxImage::CanRead(*arg1);
12088
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 {
12093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12094 }
12095 {
12096 if (created1) delete arg1;
12097 }
12098 return resultobj;
12099 fail:
12100 {
12101 if (created1) delete arg1;
12102 }
12103 return NULL;
12104 }
12105
12106
12107 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj;
12109 wxImage *arg1 = (wxImage *) 0 ;
12110 wxInputStream *arg2 = 0 ;
12111 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12112 int arg4 = (int) -1 ;
12113 bool result;
12114 wxPyInputStream *temp2 ;
12115 bool created2 ;
12116 PyObject * obj0 = 0 ;
12117 PyObject * obj1 = 0 ;
12118 PyObject * obj2 = 0 ;
12119 PyObject * obj3 = 0 ;
12120 char *kwnames[] = {
12121 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12122 };
12123
12124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12126 if (SWIG_arg_fail(1)) SWIG_fail;
12127 {
12128 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12129 arg2 = temp2->m_wxis;
12130 created2 = false;
12131 } else {
12132 PyErr_Clear(); // clear the failure of the wxPyConvert above
12133 arg2 = wxPyCBInputStream_create(obj1, false);
12134 if (arg2 == NULL) {
12135 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12136 SWIG_fail;
12137 }
12138 created2 = true;
12139 }
12140 }
12141 if (obj2) {
12142 {
12143 arg3 = (long)(SWIG_As_long(obj2));
12144 if (SWIG_arg_fail(3)) SWIG_fail;
12145 }
12146 }
12147 if (obj3) {
12148 {
12149 arg4 = (int)(SWIG_As_int(obj3));
12150 if (SWIG_arg_fail(4)) SWIG_fail;
12151 }
12152 }
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12156
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 {
12161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12162 }
12163 {
12164 if (created2) delete arg2;
12165 }
12166 return resultobj;
12167 fail:
12168 {
12169 if (created2) delete arg2;
12170 }
12171 return NULL;
12172 }
12173
12174
12175 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj;
12177 wxImage *arg1 = (wxImage *) 0 ;
12178 wxInputStream *arg2 = 0 ;
12179 wxString *arg3 = 0 ;
12180 int arg4 = (int) -1 ;
12181 bool result;
12182 wxPyInputStream *temp2 ;
12183 bool created2 ;
12184 bool temp3 = false ;
12185 PyObject * obj0 = 0 ;
12186 PyObject * obj1 = 0 ;
12187 PyObject * obj2 = 0 ;
12188 PyObject * obj3 = 0 ;
12189 char *kwnames[] = {
12190 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12191 };
12192
12193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12195 if (SWIG_arg_fail(1)) SWIG_fail;
12196 {
12197 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12198 arg2 = temp2->m_wxis;
12199 created2 = false;
12200 } else {
12201 PyErr_Clear(); // clear the failure of the wxPyConvert above
12202 arg2 = wxPyCBInputStream_create(obj1, false);
12203 if (arg2 == NULL) {
12204 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12205 SWIG_fail;
12206 }
12207 created2 = true;
12208 }
12209 }
12210 {
12211 arg3 = wxString_in_helper(obj2);
12212 if (arg3 == NULL) SWIG_fail;
12213 temp3 = true;
12214 }
12215 if (obj3) {
12216 {
12217 arg4 = (int)(SWIG_As_int(obj3));
12218 if (SWIG_arg_fail(4)) SWIG_fail;
12219 }
12220 }
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12230 }
12231 {
12232 if (created2) delete arg2;
12233 }
12234 {
12235 if (temp3)
12236 delete arg3;
12237 }
12238 return resultobj;
12239 fail:
12240 {
12241 if (created2) delete arg2;
12242 }
12243 {
12244 if (temp3)
12245 delete arg3;
12246 }
12247 return NULL;
12248 }
12249
12250
12251 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj;
12253 wxImage *arg1 = (wxImage *) 0 ;
12254 bool result;
12255 PyObject * obj0 = 0 ;
12256 char *kwnames[] = {
12257 (char *) "self", NULL
12258 };
12259
12260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12262 if (SWIG_arg_fail(1)) SWIG_fail;
12263 {
12264 PyThreadState* __tstate = wxPyBeginAllowThreads();
12265 result = (bool)(arg1)->Ok();
12266
12267 wxPyEndAllowThreads(__tstate);
12268 if (PyErr_Occurred()) SWIG_fail;
12269 }
12270 {
12271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12272 }
12273 return resultobj;
12274 fail:
12275 return NULL;
12276 }
12277
12278
12279 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj;
12281 wxImage *arg1 = (wxImage *) 0 ;
12282 int result;
12283 PyObject * obj0 = 0 ;
12284 char *kwnames[] = {
12285 (char *) "self", NULL
12286 };
12287
12288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12290 if (SWIG_arg_fail(1)) SWIG_fail;
12291 {
12292 PyThreadState* __tstate = wxPyBeginAllowThreads();
12293 result = (int)(arg1)->GetWidth();
12294
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 {
12299 resultobj = SWIG_From_int((int)(result));
12300 }
12301 return resultobj;
12302 fail:
12303 return NULL;
12304 }
12305
12306
12307 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12308 PyObject *resultobj;
12309 wxImage *arg1 = (wxImage *) 0 ;
12310 int result;
12311 PyObject * obj0 = 0 ;
12312 char *kwnames[] = {
12313 (char *) "self", NULL
12314 };
12315
12316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12318 if (SWIG_arg_fail(1)) SWIG_fail;
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (int)(arg1)->GetHeight();
12322
12323 wxPyEndAllowThreads(__tstate);
12324 if (PyErr_Occurred()) SWIG_fail;
12325 }
12326 {
12327 resultobj = SWIG_From_int((int)(result));
12328 }
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12336 PyObject *resultobj;
12337 wxImage *arg1 = (wxImage *) 0 ;
12338 wxSize result;
12339 PyObject * obj0 = 0 ;
12340 char *kwnames[] = {
12341 (char *) "self", NULL
12342 };
12343
12344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12346 if (SWIG_arg_fail(1)) SWIG_fail;
12347 {
12348 PyThreadState* __tstate = wxPyBeginAllowThreads();
12349 result = wxImage_GetSize(arg1);
12350
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 {
12355 wxSize * resultptr;
12356 resultptr = new wxSize((wxSize &)(result));
12357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12358 }
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj;
12367 wxImage *arg1 = (wxImage *) 0 ;
12368 wxRect *arg2 = 0 ;
12369 SwigValueWrapper<wxImage > result;
12370 wxRect temp2 ;
12371 PyObject * obj0 = 0 ;
12372 PyObject * obj1 = 0 ;
12373 char *kwnames[] = {
12374 (char *) "self",(char *) "rect", NULL
12375 };
12376
12377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12379 if (SWIG_arg_fail(1)) SWIG_fail;
12380 {
12381 arg2 = &temp2;
12382 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12383 }
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12387
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 {
12392 wxImage * resultptr;
12393 resultptr = new wxImage((wxImage &)(result));
12394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12395 }
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj;
12404 wxImage *arg1 = (wxImage *) 0 ;
12405 wxSize *arg2 = 0 ;
12406 wxPoint *arg3 = 0 ;
12407 int arg4 = (int) -1 ;
12408 int arg5 = (int) -1 ;
12409 int arg6 = (int) -1 ;
12410 SwigValueWrapper<wxImage > result;
12411 wxSize temp2 ;
12412 wxPoint temp3 ;
12413 PyObject * obj0 = 0 ;
12414 PyObject * obj1 = 0 ;
12415 PyObject * obj2 = 0 ;
12416 PyObject * obj3 = 0 ;
12417 PyObject * obj4 = 0 ;
12418 PyObject * obj5 = 0 ;
12419 char *kwnames[] = {
12420 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12421 };
12422
12423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12425 if (SWIG_arg_fail(1)) SWIG_fail;
12426 {
12427 arg2 = &temp2;
12428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12429 }
12430 {
12431 arg3 = &temp3;
12432 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12433 }
12434 if (obj3) {
12435 {
12436 arg4 = (int)(SWIG_As_int(obj3));
12437 if (SWIG_arg_fail(4)) SWIG_fail;
12438 }
12439 }
12440 if (obj4) {
12441 {
12442 arg5 = (int)(SWIG_As_int(obj4));
12443 if (SWIG_arg_fail(5)) SWIG_fail;
12444 }
12445 }
12446 if (obj5) {
12447 {
12448 arg6 = (int)(SWIG_As_int(obj5));
12449 if (SWIG_arg_fail(6)) SWIG_fail;
12450 }
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12455
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 wxImage * resultptr;
12461 resultptr = new wxImage((wxImage &)(result));
12462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12463 }
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxImage *arg1 = (wxImage *) 0 ;
12473 SwigValueWrapper<wxImage > result;
12474 PyObject * obj0 = 0 ;
12475 char *kwnames[] = {
12476 (char *) "self", NULL
12477 };
12478
12479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12481 if (SWIG_arg_fail(1)) SWIG_fail;
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 result = (arg1)->Copy();
12485
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 {
12490 wxImage * resultptr;
12491 resultptr = new wxImage((wxImage &)(result));
12492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12493 }
12494 return resultobj;
12495 fail:
12496 return NULL;
12497 }
12498
12499
12500 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj;
12502 wxImage *arg1 = (wxImage *) 0 ;
12503 wxImage *arg2 = 0 ;
12504 int arg3 ;
12505 int arg4 ;
12506 PyObject * obj0 = 0 ;
12507 PyObject * obj1 = 0 ;
12508 PyObject * obj2 = 0 ;
12509 PyObject * obj3 = 0 ;
12510 char *kwnames[] = {
12511 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12512 };
12513
12514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12516 if (SWIG_arg_fail(1)) SWIG_fail;
12517 {
12518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12519 if (SWIG_arg_fail(2)) SWIG_fail;
12520 if (arg2 == NULL) {
12521 SWIG_null_ref("wxImage");
12522 }
12523 if (SWIG_arg_fail(2)) SWIG_fail;
12524 }
12525 {
12526 arg3 = (int)(SWIG_As_int(obj2));
12527 if (SWIG_arg_fail(3)) SWIG_fail;
12528 }
12529 {
12530 arg4 = (int)(SWIG_As_int(obj3));
12531 if (SWIG_arg_fail(4)) SWIG_fail;
12532 }
12533 {
12534 PyThreadState* __tstate = wxPyBeginAllowThreads();
12535 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12536
12537 wxPyEndAllowThreads(__tstate);
12538 if (PyErr_Occurred()) SWIG_fail;
12539 }
12540 Py_INCREF(Py_None); resultobj = Py_None;
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12548 PyObject *resultobj;
12549 wxImage *arg1 = (wxImage *) 0 ;
12550 PyObject *result;
12551 PyObject * obj0 = 0 ;
12552 char *kwnames[] = {
12553 (char *) "self", NULL
12554 };
12555
12556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12558 if (SWIG_arg_fail(1)) SWIG_fail;
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (PyObject *)wxImage_GetData(arg1);
12562
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 resultobj = result;
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxImage *arg1 = (wxImage *) 0 ;
12576 buffer arg2 ;
12577 int arg3 ;
12578 PyObject * obj0 = 0 ;
12579 PyObject * obj1 = 0 ;
12580 char *kwnames[] = {
12581 (char *) "self",(char *) "data", NULL
12582 };
12583
12584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12586 if (SWIG_arg_fail(1)) SWIG_fail;
12587 {
12588 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12589 }
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 wxImage_SetData(arg1,arg2,arg3);
12593
12594 wxPyEndAllowThreads(__tstate);
12595 if (PyErr_Occurred()) SWIG_fail;
12596 }
12597 Py_INCREF(Py_None); resultobj = Py_None;
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12605 PyObject *resultobj;
12606 wxImage *arg1 = (wxImage *) 0 ;
12607 PyObject *result;
12608 PyObject * obj0 = 0 ;
12609 char *kwnames[] = {
12610 (char *) "self", NULL
12611 };
12612
12613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12615 if (SWIG_arg_fail(1)) SWIG_fail;
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12619
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = result;
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12631 PyObject *resultobj;
12632 wxImage *arg1 = (wxImage *) 0 ;
12633 buffer arg2 ;
12634 int arg3 ;
12635 PyObject * obj0 = 0 ;
12636 PyObject * obj1 = 0 ;
12637 char *kwnames[] = {
12638 (char *) "self",(char *) "data", NULL
12639 };
12640
12641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12643 if (SWIG_arg_fail(1)) SWIG_fail;
12644 {
12645 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12646 }
12647 {
12648 PyThreadState* __tstate = wxPyBeginAllowThreads();
12649 wxImage_SetDataBuffer(arg1,arg2,arg3);
12650
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 Py_INCREF(Py_None); resultobj = Py_None;
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12662 PyObject *resultobj;
12663 wxImage *arg1 = (wxImage *) 0 ;
12664 PyObject *result;
12665 PyObject * obj0 = 0 ;
12666 char *kwnames[] = {
12667 (char *) "self", NULL
12668 };
12669
12670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12672 if (SWIG_arg_fail(1)) SWIG_fail;
12673 {
12674 PyThreadState* __tstate = wxPyBeginAllowThreads();
12675 result = (PyObject *)wxImage_GetAlphaData(arg1);
12676
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 resultobj = result;
12681 return resultobj;
12682 fail:
12683 return NULL;
12684 }
12685
12686
12687 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12688 PyObject *resultobj;
12689 wxImage *arg1 = (wxImage *) 0 ;
12690 buffer arg2 ;
12691 int arg3 ;
12692 PyObject * obj0 = 0 ;
12693 PyObject * obj1 = 0 ;
12694 char *kwnames[] = {
12695 (char *) "self",(char *) "alpha", NULL
12696 };
12697
12698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12700 if (SWIG_arg_fail(1)) SWIG_fail;
12701 {
12702 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12703 }
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 wxImage_SetAlphaData(arg1,arg2,arg3);
12707
12708 wxPyEndAllowThreads(__tstate);
12709 if (PyErr_Occurred()) SWIG_fail;
12710 }
12711 Py_INCREF(Py_None); resultobj = Py_None;
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12719 PyObject *resultobj;
12720 wxImage *arg1 = (wxImage *) 0 ;
12721 PyObject *result;
12722 PyObject * obj0 = 0 ;
12723 char *kwnames[] = {
12724 (char *) "self", NULL
12725 };
12726
12727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12729 if (SWIG_arg_fail(1)) SWIG_fail;
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12733
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 resultobj = result;
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12745 PyObject *resultobj;
12746 wxImage *arg1 = (wxImage *) 0 ;
12747 buffer arg2 ;
12748 int arg3 ;
12749 PyObject * obj0 = 0 ;
12750 PyObject * obj1 = 0 ;
12751 char *kwnames[] = {
12752 (char *) "self",(char *) "alpha", NULL
12753 };
12754
12755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12757 if (SWIG_arg_fail(1)) SWIG_fail;
12758 {
12759 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12760 }
12761 {
12762 PyThreadState* __tstate = wxPyBeginAllowThreads();
12763 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12764
12765 wxPyEndAllowThreads(__tstate);
12766 if (PyErr_Occurred()) SWIG_fail;
12767 }
12768 Py_INCREF(Py_None); resultobj = Py_None;
12769 return resultobj;
12770 fail:
12771 return NULL;
12772 }
12773
12774
12775 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12776 PyObject *resultobj;
12777 wxImage *arg1 = (wxImage *) 0 ;
12778 unsigned char arg2 ;
12779 unsigned char arg3 ;
12780 unsigned char arg4 ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 PyObject * obj2 = 0 ;
12784 PyObject * obj3 = 0 ;
12785 char *kwnames[] = {
12786 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12787 };
12788
12789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12791 if (SWIG_arg_fail(1)) SWIG_fail;
12792 {
12793 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12794 if (SWIG_arg_fail(2)) SWIG_fail;
12795 }
12796 {
12797 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12798 if (SWIG_arg_fail(3)) SWIG_fail;
12799 }
12800 {
12801 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12802 if (SWIG_arg_fail(4)) SWIG_fail;
12803 }
12804 {
12805 PyThreadState* __tstate = wxPyBeginAllowThreads();
12806 (arg1)->SetMaskColour(arg2,arg3,arg4);
12807
12808 wxPyEndAllowThreads(__tstate);
12809 if (PyErr_Occurred()) SWIG_fail;
12810 }
12811 Py_INCREF(Py_None); resultobj = Py_None;
12812 return resultobj;
12813 fail:
12814 return NULL;
12815 }
12816
12817
12818 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12819 PyObject *resultobj;
12820 wxImage *arg1 = (wxImage *) 0 ;
12821 unsigned char *arg2 = (unsigned char *) 0 ;
12822 unsigned char *arg3 = (unsigned char *) 0 ;
12823 unsigned char *arg4 = (unsigned char *) 0 ;
12824 unsigned char temp2 ;
12825 int res2 = 0 ;
12826 unsigned char temp3 ;
12827 int res3 = 0 ;
12828 unsigned char temp4 ;
12829 int res4 = 0 ;
12830 PyObject * obj0 = 0 ;
12831 char *kwnames[] = {
12832 (char *) "self", NULL
12833 };
12834
12835 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12836 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12837 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12844
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 Py_INCREF(Py_None); resultobj = Py_None;
12849 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12850 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12851 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12852 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12853 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12854 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxImage *arg1 = (wxImage *) 0 ;
12864 unsigned char result;
12865 PyObject * obj0 = 0 ;
12866 char *kwnames[] = {
12867 (char *) "self", NULL
12868 };
12869
12870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12872 if (SWIG_arg_fail(1)) SWIG_fail;
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 result = (unsigned char)(arg1)->GetMaskRed();
12876
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 {
12881 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12882 }
12883 return resultobj;
12884 fail:
12885 return NULL;
12886 }
12887
12888
12889 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12890 PyObject *resultobj;
12891 wxImage *arg1 = (wxImage *) 0 ;
12892 unsigned char result;
12893 PyObject * obj0 = 0 ;
12894 char *kwnames[] = {
12895 (char *) "self", NULL
12896 };
12897
12898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12900 if (SWIG_arg_fail(1)) SWIG_fail;
12901 {
12902 PyThreadState* __tstate = wxPyBeginAllowThreads();
12903 result = (unsigned char)(arg1)->GetMaskGreen();
12904
12905 wxPyEndAllowThreads(__tstate);
12906 if (PyErr_Occurred()) SWIG_fail;
12907 }
12908 {
12909 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12910 }
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj;
12919 wxImage *arg1 = (wxImage *) 0 ;
12920 unsigned char result;
12921 PyObject * obj0 = 0 ;
12922 char *kwnames[] = {
12923 (char *) "self", NULL
12924 };
12925
12926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12928 if (SWIG_arg_fail(1)) SWIG_fail;
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 result = (unsigned char)(arg1)->GetMaskBlue();
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 {
12937 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12938 }
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj;
12947 wxImage *arg1 = (wxImage *) 0 ;
12948 bool arg2 = (bool) true ;
12949 PyObject * obj0 = 0 ;
12950 PyObject * obj1 = 0 ;
12951 char *kwnames[] = {
12952 (char *) "self",(char *) "mask", NULL
12953 };
12954
12955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12957 if (SWIG_arg_fail(1)) SWIG_fail;
12958 if (obj1) {
12959 {
12960 arg2 = (bool)(SWIG_As_bool(obj1));
12961 if (SWIG_arg_fail(2)) SWIG_fail;
12962 }
12963 }
12964 {
12965 PyThreadState* __tstate = wxPyBeginAllowThreads();
12966 (arg1)->SetMask(arg2);
12967
12968 wxPyEndAllowThreads(__tstate);
12969 if (PyErr_Occurred()) SWIG_fail;
12970 }
12971 Py_INCREF(Py_None); resultobj = Py_None;
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12979 PyObject *resultobj;
12980 wxImage *arg1 = (wxImage *) 0 ;
12981 bool result;
12982 PyObject * obj0 = 0 ;
12983 char *kwnames[] = {
12984 (char *) "self", NULL
12985 };
12986
12987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12989 if (SWIG_arg_fail(1)) SWIG_fail;
12990 {
12991 PyThreadState* __tstate = wxPyBeginAllowThreads();
12992 result = (bool)(arg1)->HasMask();
12993
12994 wxPyEndAllowThreads(__tstate);
12995 if (PyErr_Occurred()) SWIG_fail;
12996 }
12997 {
12998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12999 }
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj;
13008 wxImage *arg1 = (wxImage *) 0 ;
13009 double arg2 ;
13010 wxPoint *arg3 = 0 ;
13011 bool arg4 = (bool) true ;
13012 wxPoint *arg5 = (wxPoint *) NULL ;
13013 SwigValueWrapper<wxImage > result;
13014 wxPoint temp3 ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 PyObject * obj2 = 0 ;
13018 PyObject * obj3 = 0 ;
13019 PyObject * obj4 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 = (double)(SWIG_As_double(obj1));
13029 if (SWIG_arg_fail(2)) SWIG_fail;
13030 }
13031 {
13032 arg3 = &temp3;
13033 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13034 }
13035 if (obj3) {
13036 {
13037 arg4 = (bool)(SWIG_As_bool(obj3));
13038 if (SWIG_arg_fail(4)) SWIG_fail;
13039 }
13040 }
13041 if (obj4) {
13042 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13043 if (SWIG_arg_fail(5)) SWIG_fail;
13044 }
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13048
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 {
13053 wxImage * resultptr;
13054 resultptr = new wxImage((wxImage &)(result));
13055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13056 }
13057 return resultobj;
13058 fail:
13059 return NULL;
13060 }
13061
13062
13063 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj;
13065 wxImage *arg1 = (wxImage *) 0 ;
13066 bool arg2 = (bool) true ;
13067 SwigValueWrapper<wxImage > result;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 char *kwnames[] = {
13071 (char *) "self",(char *) "clockwise", NULL
13072 };
13073
13074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13076 if (SWIG_arg_fail(1)) SWIG_fail;
13077 if (obj1) {
13078 {
13079 arg2 = (bool)(SWIG_As_bool(obj1));
13080 if (SWIG_arg_fail(2)) SWIG_fail;
13081 }
13082 }
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 result = (arg1)->Rotate90(arg2);
13086
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 {
13091 wxImage * resultptr;
13092 resultptr = new wxImage((wxImage &)(result));
13093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13094 }
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxImage *arg1 = (wxImage *) 0 ;
13104 bool arg2 = (bool) true ;
13105 SwigValueWrapper<wxImage > result;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 char *kwnames[] = {
13109 (char *) "self",(char *) "horizontally", NULL
13110 };
13111
13112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13114 if (SWIG_arg_fail(1)) SWIG_fail;
13115 if (obj1) {
13116 {
13117 arg2 = (bool)(SWIG_As_bool(obj1));
13118 if (SWIG_arg_fail(2)) SWIG_fail;
13119 }
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (arg1)->Mirror(arg2);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 wxImage * resultptr;
13130 resultptr = new wxImage((wxImage &)(result));
13131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxImage *arg1 = (wxImage *) 0 ;
13142 unsigned char arg2 ;
13143 unsigned char arg3 ;
13144 unsigned char arg4 ;
13145 unsigned char arg5 ;
13146 unsigned char arg6 ;
13147 unsigned char arg7 ;
13148 PyObject * obj0 = 0 ;
13149 PyObject * obj1 = 0 ;
13150 PyObject * obj2 = 0 ;
13151 PyObject * obj3 = 0 ;
13152 PyObject * obj4 = 0 ;
13153 PyObject * obj5 = 0 ;
13154 PyObject * obj6 = 0 ;
13155 char *kwnames[] = {
13156 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13157 };
13158
13159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13161 if (SWIG_arg_fail(1)) SWIG_fail;
13162 {
13163 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13164 if (SWIG_arg_fail(2)) SWIG_fail;
13165 }
13166 {
13167 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13168 if (SWIG_arg_fail(3)) SWIG_fail;
13169 }
13170 {
13171 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13172 if (SWIG_arg_fail(4)) SWIG_fail;
13173 }
13174 {
13175 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13176 if (SWIG_arg_fail(5)) SWIG_fail;
13177 }
13178 {
13179 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13180 if (SWIG_arg_fail(6)) SWIG_fail;
13181 }
13182 {
13183 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13184 if (SWIG_arg_fail(7)) SWIG_fail;
13185 }
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13189
13190 wxPyEndAllowThreads(__tstate);
13191 if (PyErr_Occurred()) SWIG_fail;
13192 }
13193 Py_INCREF(Py_None); resultobj = Py_None;
13194 return resultobj;
13195 fail:
13196 return NULL;
13197 }
13198
13199
13200 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13201 PyObject *resultobj;
13202 wxImage *arg1 = (wxImage *) 0 ;
13203 unsigned char arg2 ;
13204 unsigned char arg3 ;
13205 unsigned char arg4 ;
13206 SwigValueWrapper<wxImage > result;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 PyObject * obj2 = 0 ;
13210 PyObject * obj3 = 0 ;
13211 char *kwnames[] = {
13212 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13213 };
13214
13215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13217 if (SWIG_arg_fail(1)) SWIG_fail;
13218 {
13219 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13220 if (SWIG_arg_fail(2)) SWIG_fail;
13221 }
13222 {
13223 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13224 if (SWIG_arg_fail(3)) SWIG_fail;
13225 }
13226 {
13227 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13228 if (SWIG_arg_fail(4)) SWIG_fail;
13229 }
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13233
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 {
13238 wxImage * resultptr;
13239 resultptr = new wxImage((wxImage &)(result));
13240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13241 }
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13249 PyObject *resultobj;
13250 wxImage *arg1 = (wxImage *) 0 ;
13251 wxString *arg2 = 0 ;
13252 wxString *arg3 = 0 ;
13253 bool temp2 = false ;
13254 bool temp3 = false ;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 PyObject * obj2 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self",(char *) "name",(char *) "value", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 {
13266 arg2 = wxString_in_helper(obj1);
13267 if (arg2 == NULL) SWIG_fail;
13268 temp2 = true;
13269 }
13270 {
13271 arg3 = wxString_in_helper(obj2);
13272 if (arg3 == NULL) SWIG_fail;
13273 temp3 = true;
13274 }
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13278
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 Py_INCREF(Py_None); resultobj = Py_None;
13283 {
13284 if (temp2)
13285 delete arg2;
13286 }
13287 {
13288 if (temp3)
13289 delete arg3;
13290 }
13291 return resultobj;
13292 fail:
13293 {
13294 if (temp2)
13295 delete arg2;
13296 }
13297 {
13298 if (temp3)
13299 delete arg3;
13300 }
13301 return NULL;
13302 }
13303
13304
13305 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13306 PyObject *resultobj;
13307 wxImage *arg1 = (wxImage *) 0 ;
13308 wxString *arg2 = 0 ;
13309 int arg3 ;
13310 bool temp2 = false ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char *kwnames[] = {
13315 (char *) "self",(char *) "name",(char *) "value", NULL
13316 };
13317
13318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13320 if (SWIG_arg_fail(1)) SWIG_fail;
13321 {
13322 arg2 = wxString_in_helper(obj1);
13323 if (arg2 == NULL) SWIG_fail;
13324 temp2 = true;
13325 }
13326 {
13327 arg3 = (int)(SWIG_As_int(obj2));
13328 if (SWIG_arg_fail(3)) SWIG_fail;
13329 }
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 (arg1)->SetOption((wxString const &)*arg2,arg3);
13333
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 Py_INCREF(Py_None); resultobj = Py_None;
13338 {
13339 if (temp2)
13340 delete arg2;
13341 }
13342 return resultobj;
13343 fail:
13344 {
13345 if (temp2)
13346 delete arg2;
13347 }
13348 return NULL;
13349 }
13350
13351
13352 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13353 PyObject *resultobj;
13354 wxImage *arg1 = (wxImage *) 0 ;
13355 wxString *arg2 = 0 ;
13356 wxString result;
13357 bool temp2 = false ;
13358 PyObject * obj0 = 0 ;
13359 PyObject * obj1 = 0 ;
13360 char *kwnames[] = {
13361 (char *) "self",(char *) "name", NULL
13362 };
13363
13364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13366 if (SWIG_arg_fail(1)) SWIG_fail;
13367 {
13368 arg2 = wxString_in_helper(obj1);
13369 if (arg2 == NULL) SWIG_fail;
13370 temp2 = true;
13371 }
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13375
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 {
13380 #if wxUSE_UNICODE
13381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13382 #else
13383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13384 #endif
13385 }
13386 {
13387 if (temp2)
13388 delete arg2;
13389 }
13390 return resultobj;
13391 fail:
13392 {
13393 if (temp2)
13394 delete arg2;
13395 }
13396 return NULL;
13397 }
13398
13399
13400 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj;
13402 wxImage *arg1 = (wxImage *) 0 ;
13403 wxString *arg2 = 0 ;
13404 int result;
13405 bool temp2 = false ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 char *kwnames[] = {
13409 (char *) "self",(char *) "name", NULL
13410 };
13411
13412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13414 if (SWIG_arg_fail(1)) SWIG_fail;
13415 {
13416 arg2 = wxString_in_helper(obj1);
13417 if (arg2 == NULL) SWIG_fail;
13418 temp2 = true;
13419 }
13420 {
13421 PyThreadState* __tstate = wxPyBeginAllowThreads();
13422 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13423
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 {
13428 resultobj = SWIG_From_int((int)(result));
13429 }
13430 {
13431 if (temp2)
13432 delete arg2;
13433 }
13434 return resultobj;
13435 fail:
13436 {
13437 if (temp2)
13438 delete arg2;
13439 }
13440 return NULL;
13441 }
13442
13443
13444 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj;
13446 wxImage *arg1 = (wxImage *) 0 ;
13447 wxString *arg2 = 0 ;
13448 bool result;
13449 bool temp2 = false ;
13450 PyObject * obj0 = 0 ;
13451 PyObject * obj1 = 0 ;
13452 char *kwnames[] = {
13453 (char *) "self",(char *) "name", NULL
13454 };
13455
13456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13458 if (SWIG_arg_fail(1)) SWIG_fail;
13459 {
13460 arg2 = wxString_in_helper(obj1);
13461 if (arg2 == NULL) SWIG_fail;
13462 temp2 = true;
13463 }
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13467
13468 wxPyEndAllowThreads(__tstate);
13469 if (PyErr_Occurred()) SWIG_fail;
13470 }
13471 {
13472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13473 }
13474 {
13475 if (temp2)
13476 delete arg2;
13477 }
13478 return resultobj;
13479 fail:
13480 {
13481 if (temp2)
13482 delete arg2;
13483 }
13484 return NULL;
13485 }
13486
13487
13488 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13489 PyObject *resultobj;
13490 wxImage *arg1 = (wxImage *) 0 ;
13491 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13492 unsigned long result;
13493 PyObject * obj0 = 0 ;
13494 PyObject * obj1 = 0 ;
13495 char *kwnames[] = {
13496 (char *) "self",(char *) "stopafter", NULL
13497 };
13498
13499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13501 if (SWIG_arg_fail(1)) SWIG_fail;
13502 if (obj1) {
13503 {
13504 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13505 if (SWIG_arg_fail(2)) SWIG_fail;
13506 }
13507 }
13508 {
13509 PyThreadState* __tstate = wxPyBeginAllowThreads();
13510 result = (unsigned long)(arg1)->CountColours(arg2);
13511
13512 wxPyEndAllowThreads(__tstate);
13513 if (PyErr_Occurred()) SWIG_fail;
13514 }
13515 {
13516 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13517 }
13518 return resultobj;
13519 fail:
13520 return NULL;
13521 }
13522
13523
13524 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13525 PyObject *resultobj;
13526 wxImage *arg1 = (wxImage *) 0 ;
13527 wxImageHistogram *arg2 = 0 ;
13528 unsigned long result;
13529 PyObject * obj0 = 0 ;
13530 PyObject * obj1 = 0 ;
13531 char *kwnames[] = {
13532 (char *) "self",(char *) "h", NULL
13533 };
13534
13535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13537 if (SWIG_arg_fail(1)) SWIG_fail;
13538 {
13539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13540 if (SWIG_arg_fail(2)) SWIG_fail;
13541 if (arg2 == NULL) {
13542 SWIG_null_ref("wxImageHistogram");
13543 }
13544 if (SWIG_arg_fail(2)) SWIG_fail;
13545 }
13546 {
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13549
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 {
13554 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13555 }
13556 return resultobj;
13557 fail:
13558 return NULL;
13559 }
13560
13561
13562 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13563 PyObject *resultobj;
13564 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13565 PyObject * obj0 = 0 ;
13566 char *kwnames[] = {
13567 (char *) "handler", NULL
13568 };
13569
13570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13572 if (SWIG_arg_fail(1)) SWIG_fail;
13573 {
13574 PyThreadState* __tstate = wxPyBeginAllowThreads();
13575 wxImage::AddHandler(arg1);
13576
13577 wxPyEndAllowThreads(__tstate);
13578 if (PyErr_Occurred()) SWIG_fail;
13579 }
13580 Py_INCREF(Py_None); resultobj = Py_None;
13581 return resultobj;
13582 fail:
13583 return NULL;
13584 }
13585
13586
13587 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13588 PyObject *resultobj;
13589 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13590 PyObject * obj0 = 0 ;
13591 char *kwnames[] = {
13592 (char *) "handler", NULL
13593 };
13594
13595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13597 if (SWIG_arg_fail(1)) SWIG_fail;
13598 {
13599 PyThreadState* __tstate = wxPyBeginAllowThreads();
13600 wxImage::InsertHandler(arg1);
13601
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 Py_INCREF(Py_None); resultobj = Py_None;
13606 return resultobj;
13607 fail:
13608 return NULL;
13609 }
13610
13611
13612 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj;
13614 wxString *arg1 = 0 ;
13615 bool result;
13616 bool temp1 = false ;
13617 PyObject * obj0 = 0 ;
13618 char *kwnames[] = {
13619 (char *) "name", NULL
13620 };
13621
13622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13623 {
13624 arg1 = wxString_in_helper(obj0);
13625 if (arg1 == NULL) SWIG_fail;
13626 temp1 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13631
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 {
13636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13637 }
13638 {
13639 if (temp1)
13640 delete arg1;
13641 }
13642 return resultobj;
13643 fail:
13644 {
13645 if (temp1)
13646 delete arg1;
13647 }
13648 return NULL;
13649 }
13650
13651
13652 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13653 PyObject *resultobj;
13654 wxString result;
13655 char *kwnames[] = {
13656 NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13660 {
13661 PyThreadState* __tstate = wxPyBeginAllowThreads();
13662 result = wxImage::GetImageExtWildcard();
13663
13664 wxPyEndAllowThreads(__tstate);
13665 if (PyErr_Occurred()) SWIG_fail;
13666 }
13667 {
13668 #if wxUSE_UNICODE
13669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13670 #else
13671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13672 #endif
13673 }
13674 return resultobj;
13675 fail:
13676 return NULL;
13677 }
13678
13679
13680 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13681 PyObject *resultobj;
13682 wxImage *arg1 = (wxImage *) 0 ;
13683 int arg2 = (int) -1 ;
13684 wxBitmap result;
13685 PyObject * obj0 = 0 ;
13686 PyObject * obj1 = 0 ;
13687 char *kwnames[] = {
13688 (char *) "self",(char *) "depth", NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13693 if (SWIG_arg_fail(1)) SWIG_fail;
13694 if (obj1) {
13695 {
13696 arg2 = (int)(SWIG_As_int(obj1));
13697 if (SWIG_arg_fail(2)) SWIG_fail;
13698 }
13699 }
13700 {
13701 if (!wxPyCheckForApp()) SWIG_fail;
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 result = wxImage_ConvertToBitmap(arg1,arg2);
13704
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 {
13709 wxBitmap * resultptr;
13710 resultptr = new wxBitmap((wxBitmap &)(result));
13711 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13712 }
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13720 PyObject *resultobj;
13721 wxImage *arg1 = (wxImage *) 0 ;
13722 unsigned char arg2 ;
13723 unsigned char arg3 ;
13724 unsigned char arg4 ;
13725 wxBitmap result;
13726 PyObject * obj0 = 0 ;
13727 PyObject * obj1 = 0 ;
13728 PyObject * obj2 = 0 ;
13729 PyObject * obj3 = 0 ;
13730 char *kwnames[] = {
13731 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13732 };
13733
13734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13736 if (SWIG_arg_fail(1)) SWIG_fail;
13737 {
13738 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13739 if (SWIG_arg_fail(2)) SWIG_fail;
13740 }
13741 {
13742 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13743 if (SWIG_arg_fail(3)) SWIG_fail;
13744 }
13745 {
13746 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13747 if (SWIG_arg_fail(4)) SWIG_fail;
13748 }
13749 {
13750 if (!wxPyCheckForApp()) SWIG_fail;
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 {
13758 wxBitmap * resultptr;
13759 resultptr = new wxBitmap((wxBitmap &)(result));
13760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13761 }
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13769 PyObject *obj;
13770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13771 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13772 Py_INCREF(obj);
13773 return Py_BuildValue((char *)"");
13774 }
13775 static int _wrap_NullImage_set(PyObject *) {
13776 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13777 return 1;
13778 }
13779
13780
13781 static PyObject *_wrap_NullImage_get(void) {
13782 PyObject *pyobj;
13783
13784 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13785 return pyobj;
13786 }
13787
13788
13789 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13790 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13791 return 1;
13792 }
13793
13794
13795 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13796 PyObject *pyobj;
13797
13798 {
13799 #if wxUSE_UNICODE
13800 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13801 #else
13802 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13803 #endif
13804 }
13805 return pyobj;
13806 }
13807
13808
13809 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13810 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13811 return 1;
13812 }
13813
13814
13815 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13816 PyObject *pyobj;
13817
13818 {
13819 #if wxUSE_UNICODE
13820 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13821 #else
13822 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13823 #endif
13824 }
13825 return pyobj;
13826 }
13827
13828
13829 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13830 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13831 return 1;
13832 }
13833
13834
13835 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13836 PyObject *pyobj;
13837
13838 {
13839 #if wxUSE_UNICODE
13840 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13841 #else
13842 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13843 #endif
13844 }
13845 return pyobj;
13846 }
13847
13848
13849 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13850 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13851 return 1;
13852 }
13853
13854
13855 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13856 PyObject *pyobj;
13857
13858 {
13859 #if wxUSE_UNICODE
13860 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13861 #else
13862 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13863 #endif
13864 }
13865 return pyobj;
13866 }
13867
13868
13869 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13870 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13871 return 1;
13872 }
13873
13874
13875 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13876 PyObject *pyobj;
13877
13878 {
13879 #if wxUSE_UNICODE
13880 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13881 #else
13882 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13883 #endif
13884 }
13885 return pyobj;
13886 }
13887
13888
13889 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13890 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13891 return 1;
13892 }
13893
13894
13895 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13896 PyObject *pyobj;
13897
13898 {
13899 #if wxUSE_UNICODE
13900 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13901 #else
13902 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13903 #endif
13904 }
13905 return pyobj;
13906 }
13907
13908
13909 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13910 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13911 return 1;
13912 }
13913
13914
13915 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13916 PyObject *pyobj;
13917
13918 {
13919 #if wxUSE_UNICODE
13920 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13921 #else
13922 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13923 #endif
13924 }
13925 return pyobj;
13926 }
13927
13928
13929 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13930 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13931 return 1;
13932 }
13933
13934
13935 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13936 PyObject *pyobj;
13937
13938 {
13939 #if wxUSE_UNICODE
13940 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13941 #else
13942 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13943 #endif
13944 }
13945 return pyobj;
13946 }
13947
13948
13949 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13950 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13951 return 1;
13952 }
13953
13954
13955 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13956 PyObject *pyobj;
13957
13958 {
13959 #if wxUSE_UNICODE
13960 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13961 #else
13962 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13963 #endif
13964 }
13965 return pyobj;
13966 }
13967
13968
13969 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13970 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13971 return 1;
13972 }
13973
13974
13975 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13976 PyObject *pyobj;
13977
13978 {
13979 #if wxUSE_UNICODE
13980 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13981 #else
13982 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13983 #endif
13984 }
13985 return pyobj;
13986 }
13987
13988
13989 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13990 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13991 return 1;
13992 }
13993
13994
13995 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13996 PyObject *pyobj;
13997
13998 {
13999 #if wxUSE_UNICODE
14000 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14001 #else
14002 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14003 #endif
14004 }
14005 return pyobj;
14006 }
14007
14008
14009 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14010 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14011 return 1;
14012 }
14013
14014
14015 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14016 PyObject *pyobj;
14017
14018 {
14019 #if wxUSE_UNICODE
14020 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14021 #else
14022 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14023 #endif
14024 }
14025 return pyobj;
14026 }
14027
14028
14029 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14030 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14031 return 1;
14032 }
14033
14034
14035 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14036 PyObject *pyobj;
14037
14038 {
14039 #if wxUSE_UNICODE
14040 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14041 #else
14042 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14043 #endif
14044 }
14045 return pyobj;
14046 }
14047
14048
14049 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14050 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14051 return 1;
14052 }
14053
14054
14055 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14056 PyObject *pyobj;
14057
14058 {
14059 #if wxUSE_UNICODE
14060 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14061 #else
14062 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14063 #endif
14064 }
14065 return pyobj;
14066 }
14067
14068
14069 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14070 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14071 return 1;
14072 }
14073
14074
14075 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14076 PyObject *pyobj;
14077
14078 {
14079 #if wxUSE_UNICODE
14080 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14081 #else
14082 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14083 #endif
14084 }
14085 return pyobj;
14086 }
14087
14088
14089 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj;
14091 wxBMPHandler *result;
14092 char *kwnames[] = {
14093 NULL
14094 };
14095
14096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14097 {
14098 PyThreadState* __tstate = wxPyBeginAllowThreads();
14099 result = (wxBMPHandler *)new wxBMPHandler();
14100
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14105 return resultobj;
14106 fail:
14107 return NULL;
14108 }
14109
14110
14111 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14112 PyObject *obj;
14113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14114 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14115 Py_INCREF(obj);
14116 return Py_BuildValue((char *)"");
14117 }
14118 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj;
14120 wxICOHandler *result;
14121 char *kwnames[] = {
14122 NULL
14123 };
14124
14125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (wxICOHandler *)new wxICOHandler();
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14141 PyObject *obj;
14142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14143 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14144 Py_INCREF(obj);
14145 return Py_BuildValue((char *)"");
14146 }
14147 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj;
14149 wxCURHandler *result;
14150 char *kwnames[] = {
14151 NULL
14152 };
14153
14154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14155 {
14156 PyThreadState* __tstate = wxPyBeginAllowThreads();
14157 result = (wxCURHandler *)new wxCURHandler();
14158
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14170 PyObject *obj;
14171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14172 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14173 Py_INCREF(obj);
14174 return Py_BuildValue((char *)"");
14175 }
14176 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxANIHandler *result;
14179 char *kwnames[] = {
14180 NULL
14181 };
14182
14183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (wxANIHandler *)new wxANIHandler();
14187
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14199 PyObject *obj;
14200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14201 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14202 Py_INCREF(obj);
14203 return Py_BuildValue((char *)"");
14204 }
14205 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj;
14207 wxPNGHandler *result;
14208 char *kwnames[] = {
14209 NULL
14210 };
14211
14212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = (wxPNGHandler *)new wxPNGHandler();
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14228 PyObject *obj;
14229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14230 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14231 Py_INCREF(obj);
14232 return Py_BuildValue((char *)"");
14233 }
14234 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj;
14236 wxGIFHandler *result;
14237 char *kwnames[] = {
14238 NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14242 {
14243 PyThreadState* __tstate = wxPyBeginAllowThreads();
14244 result = (wxGIFHandler *)new wxGIFHandler();
14245
14246 wxPyEndAllowThreads(__tstate);
14247 if (PyErr_Occurred()) SWIG_fail;
14248 }
14249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14250 return resultobj;
14251 fail:
14252 return NULL;
14253 }
14254
14255
14256 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14257 PyObject *obj;
14258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14259 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14260 Py_INCREF(obj);
14261 return Py_BuildValue((char *)"");
14262 }
14263 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj;
14265 wxPCXHandler *result;
14266 char *kwnames[] = {
14267 NULL
14268 };
14269
14270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 result = (wxPCXHandler *)new wxPCXHandler();
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14286 PyObject *obj;
14287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14288 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14289 Py_INCREF(obj);
14290 return Py_BuildValue((char *)"");
14291 }
14292 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14293 PyObject *resultobj;
14294 wxJPEGHandler *result;
14295 char *kwnames[] = {
14296 NULL
14297 };
14298
14299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 result = (wxJPEGHandler *)new wxJPEGHandler();
14303
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14315 PyObject *obj;
14316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14317 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14318 Py_INCREF(obj);
14319 return Py_BuildValue((char *)"");
14320 }
14321 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxPNMHandler *result;
14324 char *kwnames[] = {
14325 NULL
14326 };
14327
14328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14329 {
14330 PyThreadState* __tstate = wxPyBeginAllowThreads();
14331 result = (wxPNMHandler *)new wxPNMHandler();
14332
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14337 return resultobj;
14338 fail:
14339 return NULL;
14340 }
14341
14342
14343 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14344 PyObject *obj;
14345 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14346 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14347 Py_INCREF(obj);
14348 return Py_BuildValue((char *)"");
14349 }
14350 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxXPMHandler *result;
14353 char *kwnames[] = {
14354 NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (wxXPMHandler *)new wxXPMHandler();
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14373 PyObject *obj;
14374 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14375 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14376 Py_INCREF(obj);
14377 return Py_BuildValue((char *)"");
14378 }
14379 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14380 PyObject *resultobj;
14381 wxTIFFHandler *result;
14382 char *kwnames[] = {
14383 NULL
14384 };
14385
14386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14387 {
14388 PyThreadState* __tstate = wxPyBeginAllowThreads();
14389 result = (wxTIFFHandler *)new wxTIFFHandler();
14390
14391 wxPyEndAllowThreads(__tstate);
14392 if (PyErr_Occurred()) SWIG_fail;
14393 }
14394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14395 return resultobj;
14396 fail:
14397 return NULL;
14398 }
14399
14400
14401 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14402 PyObject *obj;
14403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14404 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14405 Py_INCREF(obj);
14406 return Py_BuildValue((char *)"");
14407 }
14408 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj;
14410 wxImage *arg1 = 0 ;
14411 wxImage *arg2 = 0 ;
14412 int arg3 = (int) 236 ;
14413 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14414 bool result;
14415 PyObject * obj0 = 0 ;
14416 PyObject * obj1 = 0 ;
14417 PyObject * obj2 = 0 ;
14418 PyObject * obj3 = 0 ;
14419 char *kwnames[] = {
14420 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14424 {
14425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14426 if (SWIG_arg_fail(1)) SWIG_fail;
14427 if (arg1 == NULL) {
14428 SWIG_null_ref("wxImage");
14429 }
14430 if (SWIG_arg_fail(1)) SWIG_fail;
14431 }
14432 {
14433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14434 if (SWIG_arg_fail(2)) SWIG_fail;
14435 if (arg2 == NULL) {
14436 SWIG_null_ref("wxImage");
14437 }
14438 if (SWIG_arg_fail(2)) SWIG_fail;
14439 }
14440 if (obj2) {
14441 {
14442 arg3 = (int)(SWIG_As_int(obj2));
14443 if (SWIG_arg_fail(3)) SWIG_fail;
14444 }
14445 }
14446 if (obj3) {
14447 {
14448 arg4 = (int)(SWIG_As_int(obj3));
14449 if (SWIG_arg_fail(4)) SWIG_fail;
14450 }
14451 }
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14455
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 {
14460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14461 }
14462 return resultobj;
14463 fail:
14464 return NULL;
14465 }
14466
14467
14468 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14469 PyObject *obj;
14470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14471 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14472 Py_INCREF(obj);
14473 return Py_BuildValue((char *)"");
14474 }
14475 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj;
14477 wxEvtHandler *result;
14478 char *kwnames[] = {
14479 NULL
14480 };
14481
14482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14483 {
14484 PyThreadState* __tstate = wxPyBeginAllowThreads();
14485 result = (wxEvtHandler *)new wxEvtHandler();
14486
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14491 return resultobj;
14492 fail:
14493 return NULL;
14494 }
14495
14496
14497 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj;
14499 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14500 wxEvtHandler *result;
14501 PyObject * obj0 = 0 ;
14502 char *kwnames[] = {
14503 (char *) "self", NULL
14504 };
14505
14506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14508 if (SWIG_arg_fail(1)) SWIG_fail;
14509 {
14510 PyThreadState* __tstate = wxPyBeginAllowThreads();
14511 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14512
14513 wxPyEndAllowThreads(__tstate);
14514 if (PyErr_Occurred()) SWIG_fail;
14515 }
14516 {
14517 resultobj = wxPyMake_wxObject(result, 0);
14518 }
14519 return resultobj;
14520 fail:
14521 return NULL;
14522 }
14523
14524
14525 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14526 PyObject *resultobj;
14527 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14528 wxEvtHandler *result;
14529 PyObject * obj0 = 0 ;
14530 char *kwnames[] = {
14531 (char *) "self", NULL
14532 };
14533
14534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14536 if (SWIG_arg_fail(1)) SWIG_fail;
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14540
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 {
14545 resultobj = wxPyMake_wxObject(result, 0);
14546 }
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14556 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14557 PyObject * obj0 = 0 ;
14558 PyObject * obj1 = 0 ;
14559 char *kwnames[] = {
14560 (char *) "self",(char *) "handler", NULL
14561 };
14562
14563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14565 if (SWIG_arg_fail(1)) SWIG_fail;
14566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14567 if (SWIG_arg_fail(2)) SWIG_fail;
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 (arg1)->SetNextHandler(arg2);
14571
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 Py_INCREF(Py_None); resultobj = Py_None;
14576 return resultobj;
14577 fail:
14578 return NULL;
14579 }
14580
14581
14582 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj;
14584 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14586 PyObject * obj0 = 0 ;
14587 PyObject * obj1 = 0 ;
14588 char *kwnames[] = {
14589 (char *) "self",(char *) "handler", NULL
14590 };
14591
14592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14594 if (SWIG_arg_fail(1)) SWIG_fail;
14595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14596 if (SWIG_arg_fail(2)) SWIG_fail;
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 (arg1)->SetPreviousHandler(arg2);
14600
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 Py_INCREF(Py_None); resultobj = Py_None;
14605 return resultobj;
14606 fail:
14607 return NULL;
14608 }
14609
14610
14611 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14612 PyObject *resultobj;
14613 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14614 bool result;
14615 PyObject * obj0 = 0 ;
14616 char *kwnames[] = {
14617 (char *) "self", NULL
14618 };
14619
14620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14622 if (SWIG_arg_fail(1)) SWIG_fail;
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 result = (bool)(arg1)->GetEvtHandlerEnabled();
14626
14627 wxPyEndAllowThreads(__tstate);
14628 if (PyErr_Occurred()) SWIG_fail;
14629 }
14630 {
14631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14632 }
14633 return resultobj;
14634 fail:
14635 return NULL;
14636 }
14637
14638
14639 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14640 PyObject *resultobj;
14641 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14642 bool arg2 ;
14643 PyObject * obj0 = 0 ;
14644 PyObject * obj1 = 0 ;
14645 char *kwnames[] = {
14646 (char *) "self",(char *) "enabled", NULL
14647 };
14648
14649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14651 if (SWIG_arg_fail(1)) SWIG_fail;
14652 {
14653 arg2 = (bool)(SWIG_As_bool(obj1));
14654 if (SWIG_arg_fail(2)) SWIG_fail;
14655 }
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 (arg1)->SetEvtHandlerEnabled(arg2);
14659
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 Py_INCREF(Py_None); resultobj = Py_None;
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj;
14672 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14673 wxEvent *arg2 = 0 ;
14674 bool result;
14675 PyObject * obj0 = 0 ;
14676 PyObject * obj1 = 0 ;
14677 char *kwnames[] = {
14678 (char *) "self",(char *) "event", NULL
14679 };
14680
14681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14683 if (SWIG_arg_fail(1)) SWIG_fail;
14684 {
14685 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14686 if (SWIG_arg_fail(2)) SWIG_fail;
14687 if (arg2 == NULL) {
14688 SWIG_null_ref("wxEvent");
14689 }
14690 if (SWIG_arg_fail(2)) SWIG_fail;
14691 }
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 result = (bool)(arg1)->ProcessEvent(*arg2);
14695
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 {
14700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14701 }
14702 return resultobj;
14703 fail:
14704 return NULL;
14705 }
14706
14707
14708 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14709 PyObject *resultobj;
14710 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14711 wxEvent *arg2 = 0 ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 char *kwnames[] = {
14715 (char *) "self",(char *) "event", NULL
14716 };
14717
14718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14720 if (SWIG_arg_fail(1)) SWIG_fail;
14721 {
14722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14723 if (SWIG_arg_fail(2)) SWIG_fail;
14724 if (arg2 == NULL) {
14725 SWIG_null_ref("wxEvent");
14726 }
14727 if (SWIG_arg_fail(2)) SWIG_fail;
14728 }
14729 {
14730 PyThreadState* __tstate = wxPyBeginAllowThreads();
14731 (arg1)->AddPendingEvent(*arg2);
14732
14733 wxPyEndAllowThreads(__tstate);
14734 if (PyErr_Occurred()) SWIG_fail;
14735 }
14736 Py_INCREF(Py_None); resultobj = Py_None;
14737 return resultobj;
14738 fail:
14739 return NULL;
14740 }
14741
14742
14743 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14744 PyObject *resultobj;
14745 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14746 PyObject * obj0 = 0 ;
14747 char *kwnames[] = {
14748 (char *) "self", NULL
14749 };
14750
14751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14753 if (SWIG_arg_fail(1)) SWIG_fail;
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 (arg1)->ProcessPendingEvents();
14757
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 Py_INCREF(Py_None); resultobj = Py_None;
14762 return resultobj;
14763 fail:
14764 return NULL;
14765 }
14766
14767
14768 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14769 PyObject *resultobj;
14770 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14771 int arg2 ;
14772 int arg3 ;
14773 int arg4 ;
14774 PyObject *arg5 = (PyObject *) 0 ;
14775 PyObject * obj0 = 0 ;
14776 PyObject * obj1 = 0 ;
14777 PyObject * obj2 = 0 ;
14778 PyObject * obj3 = 0 ;
14779 PyObject * obj4 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(1)) SWIG_fail;
14787 {
14788 arg2 = (int)(SWIG_As_int(obj1));
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 }
14791 {
14792 arg3 = (int)(SWIG_As_int(obj2));
14793 if (SWIG_arg_fail(3)) SWIG_fail;
14794 }
14795 {
14796 arg4 = (int)(SWIG_As_int(obj3));
14797 if (SWIG_arg_fail(4)) SWIG_fail;
14798 }
14799 arg5 = obj4;
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14803
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 Py_INCREF(Py_None); resultobj = Py_None;
14808 return resultobj;
14809 fail:
14810 return NULL;
14811 }
14812
14813
14814 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14815 PyObject *resultobj;
14816 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14817 int arg2 ;
14818 int arg3 = (int) -1 ;
14819 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14820 bool result;
14821 PyObject * obj0 = 0 ;
14822 PyObject * obj1 = 0 ;
14823 PyObject * obj2 = 0 ;
14824 PyObject * obj3 = 0 ;
14825 char *kwnames[] = {
14826 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14827 };
14828
14829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14831 if (SWIG_arg_fail(1)) SWIG_fail;
14832 {
14833 arg2 = (int)(SWIG_As_int(obj1));
14834 if (SWIG_arg_fail(2)) SWIG_fail;
14835 }
14836 if (obj2) {
14837 {
14838 arg3 = (int)(SWIG_As_int(obj2));
14839 if (SWIG_arg_fail(3)) SWIG_fail;
14840 }
14841 }
14842 if (obj3) {
14843 {
14844 arg4 = (wxEventType)(SWIG_As_int(obj3));
14845 if (SWIG_arg_fail(4)) SWIG_fail;
14846 }
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14851
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 {
14856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14857 }
14858 return resultobj;
14859 fail:
14860 return NULL;
14861 }
14862
14863
14864 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14865 PyObject *resultobj;
14866 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14867 PyObject *arg2 = (PyObject *) 0 ;
14868 bool arg3 = (bool) true ;
14869 PyObject * obj0 = 0 ;
14870 PyObject * obj1 = 0 ;
14871 PyObject * obj2 = 0 ;
14872 char *kwnames[] = {
14873 (char *) "self",(char *) "_self",(char *) "incref", NULL
14874 };
14875
14876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14878 if (SWIG_arg_fail(1)) SWIG_fail;
14879 arg2 = obj1;
14880 if (obj2) {
14881 {
14882 arg3 = (bool)(SWIG_As_bool(obj2));
14883 if (SWIG_arg_fail(3)) SWIG_fail;
14884 }
14885 }
14886 {
14887 PyThreadState* __tstate = wxPyBeginAllowThreads();
14888 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14889
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 Py_INCREF(Py_None); resultobj = Py_None;
14894 return resultobj;
14895 fail:
14896 return NULL;
14897 }
14898
14899
14900 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14901 PyObject *obj;
14902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14903 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14904 Py_INCREF(obj);
14905 return Py_BuildValue((char *)"");
14906 }
14907 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14908 PyObject *resultobj;
14909 wxEventType result;
14910 char *kwnames[] = {
14911 NULL
14912 };
14913
14914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (wxEventType)wxNewEventType();
14918
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 resultobj = SWIG_From_int((int)(result));
14924 }
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14932 PyObject *resultobj;
14933 wxEvent *arg1 = (wxEvent *) 0 ;
14934 PyObject * obj0 = 0 ;
14935 char *kwnames[] = {
14936 (char *) "self", NULL
14937 };
14938
14939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14941 if (SWIG_arg_fail(1)) SWIG_fail;
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 delete arg1;
14945
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 Py_INCREF(Py_None); resultobj = Py_None;
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxEvent *arg1 = (wxEvent *) 0 ;
14959 wxEventType arg2 ;
14960 PyObject * obj0 = 0 ;
14961 PyObject * obj1 = 0 ;
14962 char *kwnames[] = {
14963 (char *) "self",(char *) "typ", NULL
14964 };
14965
14966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14968 if (SWIG_arg_fail(1)) SWIG_fail;
14969 {
14970 arg2 = (wxEventType)(SWIG_As_int(obj1));
14971 if (SWIG_arg_fail(2)) SWIG_fail;
14972 }
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 (arg1)->SetEventType(arg2);
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 Py_INCREF(Py_None); resultobj = Py_None;
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj;
14989 wxEvent *arg1 = (wxEvent *) 0 ;
14990 wxEventType result;
14991 PyObject * obj0 = 0 ;
14992 char *kwnames[] = {
14993 (char *) "self", NULL
14994 };
14995
14996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14998 if (SWIG_arg_fail(1)) SWIG_fail;
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15002
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 {
15007 resultobj = SWIG_From_int((int)(result));
15008 }
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15016 PyObject *resultobj;
15017 wxEvent *arg1 = (wxEvent *) 0 ;
15018 wxObject *result;
15019 PyObject * obj0 = 0 ;
15020 char *kwnames[] = {
15021 (char *) "self", NULL
15022 };
15023
15024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15026 if (SWIG_arg_fail(1)) SWIG_fail;
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15030
15031 wxPyEndAllowThreads(__tstate);
15032 if (PyErr_Occurred()) SWIG_fail;
15033 }
15034 {
15035 resultobj = wxPyMake_wxObject(result, 0);
15036 }
15037 return resultobj;
15038 fail:
15039 return NULL;
15040 }
15041
15042
15043 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj;
15045 wxEvent *arg1 = (wxEvent *) 0 ;
15046 wxObject *arg2 = (wxObject *) 0 ;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 char *kwnames[] = {
15050 (char *) "self",(char *) "obj", NULL
15051 };
15052
15053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15055 if (SWIG_arg_fail(1)) SWIG_fail;
15056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15057 if (SWIG_arg_fail(2)) SWIG_fail;
15058 {
15059 PyThreadState* __tstate = wxPyBeginAllowThreads();
15060 (arg1)->SetEventObject(arg2);
15061
15062 wxPyEndAllowThreads(__tstate);
15063 if (PyErr_Occurred()) SWIG_fail;
15064 }
15065 Py_INCREF(Py_None); resultobj = Py_None;
15066 return resultobj;
15067 fail:
15068 return NULL;
15069 }
15070
15071
15072 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15073 PyObject *resultobj;
15074 wxEvent *arg1 = (wxEvent *) 0 ;
15075 long result;
15076 PyObject * obj0 = 0 ;
15077 char *kwnames[] = {
15078 (char *) "self", NULL
15079 };
15080
15081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15083 if (SWIG_arg_fail(1)) SWIG_fail;
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15087
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 {
15092 resultobj = SWIG_From_long((long)(result));
15093 }
15094 return resultobj;
15095 fail:
15096 return NULL;
15097 }
15098
15099
15100 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15101 PyObject *resultobj;
15102 wxEvent *arg1 = (wxEvent *) 0 ;
15103 long arg2 = (long) 0 ;
15104 PyObject * obj0 = 0 ;
15105 PyObject * obj1 = 0 ;
15106 char *kwnames[] = {
15107 (char *) "self",(char *) "ts", NULL
15108 };
15109
15110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15112 if (SWIG_arg_fail(1)) SWIG_fail;
15113 if (obj1) {
15114 {
15115 arg2 = (long)(SWIG_As_long(obj1));
15116 if (SWIG_arg_fail(2)) SWIG_fail;
15117 }
15118 }
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 (arg1)->SetTimestamp(arg2);
15122
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 Py_INCREF(Py_None); resultobj = Py_None;
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj;
15135 wxEvent *arg1 = (wxEvent *) 0 ;
15136 int result;
15137 PyObject * obj0 = 0 ;
15138 char *kwnames[] = {
15139 (char *) "self", NULL
15140 };
15141
15142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15144 if (SWIG_arg_fail(1)) SWIG_fail;
15145 {
15146 PyThreadState* __tstate = wxPyBeginAllowThreads();
15147 result = (int)((wxEvent const *)arg1)->GetId();
15148
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 {
15153 resultobj = SWIG_From_int((int)(result));
15154 }
15155 return resultobj;
15156 fail:
15157 return NULL;
15158 }
15159
15160
15161 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj;
15163 wxEvent *arg1 = (wxEvent *) 0 ;
15164 int arg2 ;
15165 PyObject * obj0 = 0 ;
15166 PyObject * obj1 = 0 ;
15167 char *kwnames[] = {
15168 (char *) "self",(char *) "Id", NULL
15169 };
15170
15171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15173 if (SWIG_arg_fail(1)) SWIG_fail;
15174 {
15175 arg2 = (int)(SWIG_As_int(obj1));
15176 if (SWIG_arg_fail(2)) SWIG_fail;
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 (arg1)->SetId(arg2);
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 Py_INCREF(Py_None); resultobj = Py_None;
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15193 PyObject *resultobj;
15194 wxEvent *arg1 = (wxEvent *) 0 ;
15195 bool result;
15196 PyObject * obj0 = 0 ;
15197 char *kwnames[] = {
15198 (char *) "self", NULL
15199 };
15200
15201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15203 if (SWIG_arg_fail(1)) SWIG_fail;
15204 {
15205 PyThreadState* __tstate = wxPyBeginAllowThreads();
15206 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15207
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 {
15212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15213 }
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj;
15222 wxEvent *arg1 = (wxEvent *) 0 ;
15223 bool arg2 = (bool) true ;
15224 PyObject * obj0 = 0 ;
15225 PyObject * obj1 = 0 ;
15226 char *kwnames[] = {
15227 (char *) "self",(char *) "skip", NULL
15228 };
15229
15230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15232 if (SWIG_arg_fail(1)) SWIG_fail;
15233 if (obj1) {
15234 {
15235 arg2 = (bool)(SWIG_As_bool(obj1));
15236 if (SWIG_arg_fail(2)) SWIG_fail;
15237 }
15238 }
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 (arg1)->Skip(arg2);
15242
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 Py_INCREF(Py_None); resultobj = Py_None;
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15254 PyObject *resultobj;
15255 wxEvent *arg1 = (wxEvent *) 0 ;
15256 bool result;
15257 PyObject * obj0 = 0 ;
15258 char *kwnames[] = {
15259 (char *) "self", NULL
15260 };
15261
15262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15268
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 {
15273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15274 }
15275 return resultobj;
15276 fail:
15277 return NULL;
15278 }
15279
15280
15281 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15282 PyObject *resultobj;
15283 wxEvent *arg1 = (wxEvent *) 0 ;
15284 bool result;
15285 PyObject * obj0 = 0 ;
15286 char *kwnames[] = {
15287 (char *) "self", NULL
15288 };
15289
15290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15292 if (SWIG_arg_fail(1)) SWIG_fail;
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15296
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 {
15301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15302 }
15303 return resultobj;
15304 fail:
15305 return NULL;
15306 }
15307
15308
15309 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15310 PyObject *resultobj;
15311 wxEvent *arg1 = (wxEvent *) 0 ;
15312 int result;
15313 PyObject * obj0 = 0 ;
15314 char *kwnames[] = {
15315 (char *) "self", NULL
15316 };
15317
15318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15320 if (SWIG_arg_fail(1)) SWIG_fail;
15321 {
15322 PyThreadState* __tstate = wxPyBeginAllowThreads();
15323 result = (int)(arg1)->StopPropagation();
15324
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 {
15329 resultobj = SWIG_From_int((int)(result));
15330 }
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15338 PyObject *resultobj;
15339 wxEvent *arg1 = (wxEvent *) 0 ;
15340 int arg2 ;
15341 PyObject * obj0 = 0 ;
15342 PyObject * obj1 = 0 ;
15343 char *kwnames[] = {
15344 (char *) "self",(char *) "propagationLevel", NULL
15345 };
15346
15347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15349 if (SWIG_arg_fail(1)) SWIG_fail;
15350 {
15351 arg2 = (int)(SWIG_As_int(obj1));
15352 if (SWIG_arg_fail(2)) SWIG_fail;
15353 }
15354 {
15355 PyThreadState* __tstate = wxPyBeginAllowThreads();
15356 (arg1)->ResumePropagation(arg2);
15357
15358 wxPyEndAllowThreads(__tstate);
15359 if (PyErr_Occurred()) SWIG_fail;
15360 }
15361 Py_INCREF(Py_None); resultobj = Py_None;
15362 return resultobj;
15363 fail:
15364 return NULL;
15365 }
15366
15367
15368 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15369 PyObject *resultobj;
15370 wxEvent *arg1 = (wxEvent *) 0 ;
15371 wxEvent *result;
15372 PyObject * obj0 = 0 ;
15373 char *kwnames[] = {
15374 (char *) "self", NULL
15375 };
15376
15377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15379 if (SWIG_arg_fail(1)) SWIG_fail;
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 result = (wxEvent *)(arg1)->Clone();
15383
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15395 PyObject *obj;
15396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15397 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15398 Py_INCREF(obj);
15399 return Py_BuildValue((char *)"");
15400 }
15401 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj;
15403 wxEvent *arg1 = 0 ;
15404 wxPropagationDisabler *result;
15405 PyObject * obj0 = 0 ;
15406 char *kwnames[] = {
15407 (char *) "event", NULL
15408 };
15409
15410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15411 {
15412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(1)) SWIG_fail;
15414 if (arg1 == NULL) {
15415 SWIG_null_ref("wxEvent");
15416 }
15417 if (SWIG_arg_fail(1)) SWIG_fail;
15418 }
15419 {
15420 PyThreadState* __tstate = wxPyBeginAllowThreads();
15421 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15422
15423 wxPyEndAllowThreads(__tstate);
15424 if (PyErr_Occurred()) SWIG_fail;
15425 }
15426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15427 return resultobj;
15428 fail:
15429 return NULL;
15430 }
15431
15432
15433 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15434 PyObject *resultobj;
15435 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15436 PyObject * obj0 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 PyThreadState* __tstate = wxPyBeginAllowThreads();
15446 delete arg1;
15447
15448 wxPyEndAllowThreads(__tstate);
15449 if (PyErr_Occurred()) SWIG_fail;
15450 }
15451 Py_INCREF(Py_None); resultobj = Py_None;
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15459 PyObject *obj;
15460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15461 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15462 Py_INCREF(obj);
15463 return Py_BuildValue((char *)"");
15464 }
15465 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15466 PyObject *resultobj;
15467 wxEvent *arg1 = 0 ;
15468 wxPropagateOnce *result;
15469 PyObject * obj0 = 0 ;
15470 char *kwnames[] = {
15471 (char *) "event", NULL
15472 };
15473
15474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15475 {
15476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15477 if (SWIG_arg_fail(1)) SWIG_fail;
15478 if (arg1 == NULL) {
15479 SWIG_null_ref("wxEvent");
15480 }
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 }
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15486
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15491 return resultobj;
15492 fail:
15493 return NULL;
15494 }
15495
15496
15497 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15498 PyObject *resultobj;
15499 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15500 PyObject * obj0 = 0 ;
15501 char *kwnames[] = {
15502 (char *) "self", NULL
15503 };
15504
15505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15507 if (SWIG_arg_fail(1)) SWIG_fail;
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 delete arg1;
15511
15512 wxPyEndAllowThreads(__tstate);
15513 if (PyErr_Occurred()) SWIG_fail;
15514 }
15515 Py_INCREF(Py_None); resultobj = Py_None;
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15523 PyObject *obj;
15524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15525 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15526 Py_INCREF(obj);
15527 return Py_BuildValue((char *)"");
15528 }
15529 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15530 PyObject *resultobj;
15531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15532 int arg2 = (int) 0 ;
15533 wxCommandEvent *result;
15534 PyObject * obj0 = 0 ;
15535 PyObject * obj1 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "commandType",(char *) "winid", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15541 if (obj0) {
15542 {
15543 arg1 = (wxEventType)(SWIG_As_int(obj0));
15544 if (SWIG_arg_fail(1)) SWIG_fail;
15545 }
15546 }
15547 if (obj1) {
15548 {
15549 arg2 = (int)(SWIG_As_int(obj1));
15550 if (SWIG_arg_fail(2)) SWIG_fail;
15551 }
15552 }
15553 {
15554 PyThreadState* __tstate = wxPyBeginAllowThreads();
15555 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15556
15557 wxPyEndAllowThreads(__tstate);
15558 if (PyErr_Occurred()) SWIG_fail;
15559 }
15560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15561 return resultobj;
15562 fail:
15563 return NULL;
15564 }
15565
15566
15567 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15568 PyObject *resultobj;
15569 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15570 int result;
15571 PyObject * obj0 = 0 ;
15572 char *kwnames[] = {
15573 (char *) "self", NULL
15574 };
15575
15576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15578 if (SWIG_arg_fail(1)) SWIG_fail;
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15582
15583 wxPyEndAllowThreads(__tstate);
15584 if (PyErr_Occurred()) SWIG_fail;
15585 }
15586 {
15587 resultobj = SWIG_From_int((int)(result));
15588 }
15589 return resultobj;
15590 fail:
15591 return NULL;
15592 }
15593
15594
15595 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15596 PyObject *resultobj;
15597 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15598 wxString *arg2 = 0 ;
15599 bool temp2 = false ;
15600 PyObject * obj0 = 0 ;
15601 PyObject * obj1 = 0 ;
15602 char *kwnames[] = {
15603 (char *) "self",(char *) "s", NULL
15604 };
15605
15606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15608 if (SWIG_arg_fail(1)) SWIG_fail;
15609 {
15610 arg2 = wxString_in_helper(obj1);
15611 if (arg2 == NULL) SWIG_fail;
15612 temp2 = true;
15613 }
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 (arg1)->SetString((wxString const &)*arg2);
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 Py_INCREF(Py_None); resultobj = Py_None;
15622 {
15623 if (temp2)
15624 delete arg2;
15625 }
15626 return resultobj;
15627 fail:
15628 {
15629 if (temp2)
15630 delete arg2;
15631 }
15632 return NULL;
15633 }
15634
15635
15636 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15637 PyObject *resultobj;
15638 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15639 wxString result;
15640 PyObject * obj0 = 0 ;
15641 char *kwnames[] = {
15642 (char *) "self", NULL
15643 };
15644
15645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15647 if (SWIG_arg_fail(1)) SWIG_fail;
15648 {
15649 PyThreadState* __tstate = wxPyBeginAllowThreads();
15650 result = ((wxCommandEvent const *)arg1)->GetString();
15651
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 {
15656 #if wxUSE_UNICODE
15657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15658 #else
15659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15660 #endif
15661 }
15662 return resultobj;
15663 fail:
15664 return NULL;
15665 }
15666
15667
15668 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15669 PyObject *resultobj;
15670 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15671 bool result;
15672 PyObject * obj0 = 0 ;
15673 char *kwnames[] = {
15674 (char *) "self", NULL
15675 };
15676
15677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15679 if (SWIG_arg_fail(1)) SWIG_fail;
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 {
15688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15689 }
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15697 PyObject *resultobj;
15698 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15699 bool result;
15700 PyObject * obj0 = 0 ;
15701 char *kwnames[] = {
15702 (char *) "self", NULL
15703 };
15704
15705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15707 if (SWIG_arg_fail(1)) SWIG_fail;
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15711
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 {
15716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15717 }
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj;
15726 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15727 long arg2 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 char *kwnames[] = {
15731 (char *) "self",(char *) "extraLong", NULL
15732 };
15733
15734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15736 if (SWIG_arg_fail(1)) SWIG_fail;
15737 {
15738 arg2 = (long)(SWIG_As_long(obj1));
15739 if (SWIG_arg_fail(2)) SWIG_fail;
15740 }
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 (arg1)->SetExtraLong(arg2);
15744
15745 wxPyEndAllowThreads(__tstate);
15746 if (PyErr_Occurred()) SWIG_fail;
15747 }
15748 Py_INCREF(Py_None); resultobj = Py_None;
15749 return resultobj;
15750 fail:
15751 return NULL;
15752 }
15753
15754
15755 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15756 PyObject *resultobj;
15757 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15758 long result;
15759 PyObject * obj0 = 0 ;
15760 char *kwnames[] = {
15761 (char *) "self", NULL
15762 };
15763
15764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15766 if (SWIG_arg_fail(1)) SWIG_fail;
15767 {
15768 PyThreadState* __tstate = wxPyBeginAllowThreads();
15769 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15770
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 {
15775 resultobj = SWIG_From_long((long)(result));
15776 }
15777 return resultobj;
15778 fail:
15779 return NULL;
15780 }
15781
15782
15783 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15784 PyObject *resultobj;
15785 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15786 int arg2 ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 char *kwnames[] = {
15790 (char *) "self",(char *) "i", NULL
15791 };
15792
15793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15795 if (SWIG_arg_fail(1)) SWIG_fail;
15796 {
15797 arg2 = (int)(SWIG_As_int(obj1));
15798 if (SWIG_arg_fail(2)) SWIG_fail;
15799 }
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 (arg1)->SetInt(arg2);
15803
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 Py_INCREF(Py_None); resultobj = Py_None;
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj;
15816 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15817 long result;
15818 PyObject * obj0 = 0 ;
15819 char *kwnames[] = {
15820 (char *) "self", NULL
15821 };
15822
15823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15825 if (SWIG_arg_fail(1)) SWIG_fail;
15826 {
15827 PyThreadState* __tstate = wxPyBeginAllowThreads();
15828 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15829
15830 wxPyEndAllowThreads(__tstate);
15831 if (PyErr_Occurred()) SWIG_fail;
15832 }
15833 {
15834 resultobj = SWIG_From_long((long)(result));
15835 }
15836 return resultobj;
15837 fail:
15838 return NULL;
15839 }
15840
15841
15842 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15843 PyObject *resultobj;
15844 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15845 wxEvent *result;
15846 PyObject * obj0 = 0 ;
15847 char *kwnames[] = {
15848 (char *) "self", NULL
15849 };
15850
15851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15853 if (SWIG_arg_fail(1)) SWIG_fail;
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15857
15858 wxPyEndAllowThreads(__tstate);
15859 if (PyErr_Occurred()) SWIG_fail;
15860 }
15861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15862 return resultobj;
15863 fail:
15864 return NULL;
15865 }
15866
15867
15868 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15869 PyObject *obj;
15870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15871 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15872 Py_INCREF(obj);
15873 return Py_BuildValue((char *)"");
15874 }
15875 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj;
15877 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15878 int arg2 = (int) 0 ;
15879 wxNotifyEvent *result;
15880 PyObject * obj0 = 0 ;
15881 PyObject * obj1 = 0 ;
15882 char *kwnames[] = {
15883 (char *) "commandType",(char *) "winid", NULL
15884 };
15885
15886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15887 if (obj0) {
15888 {
15889 arg1 = (wxEventType)(SWIG_As_int(obj0));
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 }
15892 }
15893 if (obj1) {
15894 {
15895 arg2 = (int)(SWIG_As_int(obj1));
15896 if (SWIG_arg_fail(2)) SWIG_fail;
15897 }
15898 }
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15902
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj;
15915 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15916 PyObject * obj0 = 0 ;
15917 char *kwnames[] = {
15918 (char *) "self", NULL
15919 };
15920
15921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15923 if (SWIG_arg_fail(1)) SWIG_fail;
15924 {
15925 PyThreadState* __tstate = wxPyBeginAllowThreads();
15926 (arg1)->Veto();
15927
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 Py_INCREF(Py_None); resultobj = Py_None;
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15939 PyObject *resultobj;
15940 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15941 PyObject * obj0 = 0 ;
15942 char *kwnames[] = {
15943 (char *) "self", NULL
15944 };
15945
15946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15948 if (SWIG_arg_fail(1)) SWIG_fail;
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 (arg1)->Allow();
15952
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 Py_INCREF(Py_None); resultobj = Py_None;
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj;
15965 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15966 bool result;
15967 PyObject * obj0 = 0 ;
15968 char *kwnames[] = {
15969 (char *) "self", NULL
15970 };
15971
15972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15974 if (SWIG_arg_fail(1)) SWIG_fail;
15975 {
15976 PyThreadState* __tstate = wxPyBeginAllowThreads();
15977 result = (bool)(arg1)->IsAllowed();
15978
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 {
15983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15984 }
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15992 PyObject *obj;
15993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15994 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15995 Py_INCREF(obj);
15996 return Py_BuildValue((char *)"");
15997 }
15998 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15999 PyObject *resultobj;
16000 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16001 int arg2 = (int) 0 ;
16002 int arg3 = (int) 0 ;
16003 int arg4 = (int) 0 ;
16004 wxScrollEvent *result;
16005 PyObject * obj0 = 0 ;
16006 PyObject * obj1 = 0 ;
16007 PyObject * obj2 = 0 ;
16008 PyObject * obj3 = 0 ;
16009 char *kwnames[] = {
16010 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16011 };
16012
16013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16014 if (obj0) {
16015 {
16016 arg1 = (wxEventType)(SWIG_As_int(obj0));
16017 if (SWIG_arg_fail(1)) SWIG_fail;
16018 }
16019 }
16020 if (obj1) {
16021 {
16022 arg2 = (int)(SWIG_As_int(obj1));
16023 if (SWIG_arg_fail(2)) SWIG_fail;
16024 }
16025 }
16026 if (obj2) {
16027 {
16028 arg3 = (int)(SWIG_As_int(obj2));
16029 if (SWIG_arg_fail(3)) SWIG_fail;
16030 }
16031 }
16032 if (obj3) {
16033 {
16034 arg4 = (int)(SWIG_As_int(obj3));
16035 if (SWIG_arg_fail(4)) SWIG_fail;
16036 }
16037 }
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16041
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj;
16054 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16055 int result;
16056 PyObject * obj0 = 0 ;
16057 char *kwnames[] = {
16058 (char *) "self", NULL
16059 };
16060
16061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16063 if (SWIG_arg_fail(1)) SWIG_fail;
16064 {
16065 PyThreadState* __tstate = wxPyBeginAllowThreads();
16066 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16067
16068 wxPyEndAllowThreads(__tstate);
16069 if (PyErr_Occurred()) SWIG_fail;
16070 }
16071 {
16072 resultobj = SWIG_From_int((int)(result));
16073 }
16074 return resultobj;
16075 fail:
16076 return NULL;
16077 }
16078
16079
16080 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16081 PyObject *resultobj;
16082 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16083 int result;
16084 PyObject * obj0 = 0 ;
16085 char *kwnames[] = {
16086 (char *) "self", NULL
16087 };
16088
16089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16091 if (SWIG_arg_fail(1)) SWIG_fail;
16092 {
16093 PyThreadState* __tstate = wxPyBeginAllowThreads();
16094 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16095
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 {
16100 resultobj = SWIG_From_int((int)(result));
16101 }
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj;
16110 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16111 int arg2 ;
16112 PyObject * obj0 = 0 ;
16113 PyObject * obj1 = 0 ;
16114 char *kwnames[] = {
16115 (char *) "self",(char *) "orient", NULL
16116 };
16117
16118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16120 if (SWIG_arg_fail(1)) SWIG_fail;
16121 {
16122 arg2 = (int)(SWIG_As_int(obj1));
16123 if (SWIG_arg_fail(2)) SWIG_fail;
16124 }
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 (arg1)->SetOrientation(arg2);
16128
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 Py_INCREF(Py_None); resultobj = Py_None;
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16140 PyObject *resultobj;
16141 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16142 int arg2 ;
16143 PyObject * obj0 = 0 ;
16144 PyObject * obj1 = 0 ;
16145 char *kwnames[] = {
16146 (char *) "self",(char *) "pos", NULL
16147 };
16148
16149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16151 if (SWIG_arg_fail(1)) SWIG_fail;
16152 {
16153 arg2 = (int)(SWIG_As_int(obj1));
16154 if (SWIG_arg_fail(2)) SWIG_fail;
16155 }
16156 {
16157 PyThreadState* __tstate = wxPyBeginAllowThreads();
16158 (arg1)->SetPosition(arg2);
16159
16160 wxPyEndAllowThreads(__tstate);
16161 if (PyErr_Occurred()) SWIG_fail;
16162 }
16163 Py_INCREF(Py_None); resultobj = Py_None;
16164 return resultobj;
16165 fail:
16166 return NULL;
16167 }
16168
16169
16170 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16171 PyObject *obj;
16172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16173 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16174 Py_INCREF(obj);
16175 return Py_BuildValue((char *)"");
16176 }
16177 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16178 PyObject *resultobj;
16179 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16180 int arg2 = (int) 0 ;
16181 int arg3 = (int) 0 ;
16182 wxScrollWinEvent *result;
16183 PyObject * obj0 = 0 ;
16184 PyObject * obj1 = 0 ;
16185 PyObject * obj2 = 0 ;
16186 char *kwnames[] = {
16187 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16188 };
16189
16190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16191 if (obj0) {
16192 {
16193 arg1 = (wxEventType)(SWIG_As_int(obj0));
16194 if (SWIG_arg_fail(1)) SWIG_fail;
16195 }
16196 }
16197 if (obj1) {
16198 {
16199 arg2 = (int)(SWIG_As_int(obj1));
16200 if (SWIG_arg_fail(2)) SWIG_fail;
16201 }
16202 }
16203 if (obj2) {
16204 {
16205 arg3 = (int)(SWIG_As_int(obj2));
16206 if (SWIG_arg_fail(3)) SWIG_fail;
16207 }
16208 }
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16224 PyObject *resultobj;
16225 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16226 int result;
16227 PyObject * obj0 = 0 ;
16228 char *kwnames[] = {
16229 (char *) "self", NULL
16230 };
16231
16232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16234 if (SWIG_arg_fail(1)) SWIG_fail;
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16238
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 {
16243 resultobj = SWIG_From_int((int)(result));
16244 }
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16252 PyObject *resultobj;
16253 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16254 int result;
16255 PyObject * obj0 = 0 ;
16256 char *kwnames[] = {
16257 (char *) "self", NULL
16258 };
16259
16260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16262 if (SWIG_arg_fail(1)) SWIG_fail;
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16266
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 {
16271 resultobj = SWIG_From_int((int)(result));
16272 }
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj;
16281 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16282 int arg2 ;
16283 PyObject * obj0 = 0 ;
16284 PyObject * obj1 = 0 ;
16285 char *kwnames[] = {
16286 (char *) "self",(char *) "orient", NULL
16287 };
16288
16289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16291 if (SWIG_arg_fail(1)) SWIG_fail;
16292 {
16293 arg2 = (int)(SWIG_As_int(obj1));
16294 if (SWIG_arg_fail(2)) SWIG_fail;
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 (arg1)->SetOrientation(arg2);
16299
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 Py_INCREF(Py_None); resultobj = Py_None;
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj;
16312 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16313 int arg2 ;
16314 PyObject * obj0 = 0 ;
16315 PyObject * obj1 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self",(char *) "pos", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 {
16324 arg2 = (int)(SWIG_As_int(obj1));
16325 if (SWIG_arg_fail(2)) SWIG_fail;
16326 }
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 (arg1)->SetPosition(arg2);
16330
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 Py_INCREF(Py_None); resultobj = Py_None;
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16342 PyObject *obj;
16343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16344 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16345 Py_INCREF(obj);
16346 return Py_BuildValue((char *)"");
16347 }
16348 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj;
16350 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16351 wxMouseEvent *result;
16352 PyObject * obj0 = 0 ;
16353 char *kwnames[] = {
16354 (char *) "mouseType", NULL
16355 };
16356
16357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16358 if (obj0) {
16359 {
16360 arg1 = (wxEventType)(SWIG_As_int(obj0));
16361 if (SWIG_arg_fail(1)) SWIG_fail;
16362 }
16363 }
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16367
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 {
16372 resultobj = wxPyMake_wxObject(result, 1);
16373 }
16374 return resultobj;
16375 fail:
16376 return NULL;
16377 }
16378
16379
16380 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16381 PyObject *resultobj;
16382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16383 bool result;
16384 PyObject * obj0 = 0 ;
16385 char *kwnames[] = {
16386 (char *) "self", NULL
16387 };
16388
16389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16391 if (SWIG_arg_fail(1)) SWIG_fail;
16392 {
16393 PyThreadState* __tstate = wxPyBeginAllowThreads();
16394 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16395
16396 wxPyEndAllowThreads(__tstate);
16397 if (PyErr_Occurred()) SWIG_fail;
16398 }
16399 {
16400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16401 }
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj;
16410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16411 int arg2 = (int) wxMOUSE_BTN_ANY ;
16412 bool result;
16413 PyObject * obj0 = 0 ;
16414 PyObject * obj1 = 0 ;
16415 char *kwnames[] = {
16416 (char *) "self",(char *) "but", NULL
16417 };
16418
16419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16421 if (SWIG_arg_fail(1)) SWIG_fail;
16422 if (obj1) {
16423 {
16424 arg2 = (int)(SWIG_As_int(obj1));
16425 if (SWIG_arg_fail(2)) SWIG_fail;
16426 }
16427 }
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
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_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj;
16446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16447 int arg2 = (int) wxMOUSE_BTN_ANY ;
16448 bool result;
16449 PyObject * obj0 = 0 ;
16450 PyObject * obj1 = 0 ;
16451 char *kwnames[] = {
16452 (char *) "self",(char *) "but", NULL
16453 };
16454
16455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16457 if (SWIG_arg_fail(1)) SWIG_fail;
16458 if (obj1) {
16459 {
16460 arg2 = (int)(SWIG_As_int(obj1));
16461 if (SWIG_arg_fail(2)) SWIG_fail;
16462 }
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16467
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 {
16472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16473 }
16474 return resultobj;
16475 fail:
16476 return NULL;
16477 }
16478
16479
16480 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16481 PyObject *resultobj;
16482 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16483 int arg2 = (int) wxMOUSE_BTN_ANY ;
16484 bool result;
16485 PyObject * obj0 = 0 ;
16486 PyObject * obj1 = 0 ;
16487 char *kwnames[] = {
16488 (char *) "self",(char *) "but", NULL
16489 };
16490
16491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16493 if (SWIG_arg_fail(1)) SWIG_fail;
16494 if (obj1) {
16495 {
16496 arg2 = (int)(SWIG_As_int(obj1));
16497 if (SWIG_arg_fail(2)) SWIG_fail;
16498 }
16499 }
16500 {
16501 PyThreadState* __tstate = wxPyBeginAllowThreads();
16502 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16503
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 {
16508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16509 }
16510 return resultobj;
16511 fail:
16512 return NULL;
16513 }
16514
16515
16516 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj;
16518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16519 int arg2 ;
16520 bool result;
16521 PyObject * obj0 = 0 ;
16522 PyObject * obj1 = 0 ;
16523 char *kwnames[] = {
16524 (char *) "self",(char *) "but", NULL
16525 };
16526
16527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16529 if (SWIG_arg_fail(1)) SWIG_fail;
16530 {
16531 arg2 = (int)(SWIG_As_int(obj1));
16532 if (SWIG_arg_fail(2)) SWIG_fail;
16533 }
16534 {
16535 PyThreadState* __tstate = wxPyBeginAllowThreads();
16536 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16537
16538 wxPyEndAllowThreads(__tstate);
16539 if (PyErr_Occurred()) SWIG_fail;
16540 }
16541 {
16542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16543 }
16544 return resultobj;
16545 fail:
16546 return NULL;
16547 }
16548
16549
16550 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16551 PyObject *resultobj;
16552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16553 int arg2 ;
16554 bool result;
16555 PyObject * obj0 = 0 ;
16556 PyObject * obj1 = 0 ;
16557 char *kwnames[] = {
16558 (char *) "self",(char *) "but", NULL
16559 };
16560
16561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16563 if (SWIG_arg_fail(1)) SWIG_fail;
16564 {
16565 arg2 = (int)(SWIG_As_int(obj1));
16566 if (SWIG_arg_fail(2)) SWIG_fail;
16567 }
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
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_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16585 PyObject *resultobj;
16586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16587 int result;
16588 PyObject * obj0 = 0 ;
16589 char *kwnames[] = {
16590 (char *) "self", NULL
16591 };
16592
16593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",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 = (int)((wxMouseEvent const *)arg1)->GetButton();
16599
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 {
16604 resultobj = SWIG_From_int((int)(result));
16605 }
16606 return resultobj;
16607 fail:
16608 return NULL;
16609 }
16610
16611
16612 static PyObject *_wrap_MouseEvent_ControlDown(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_ControlDown",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)((wxMouseEvent const *)arg1)->ControlDown();
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_MetaDown(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_MetaDown",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)->MetaDown();
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_AltDown(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_AltDown",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)->AltDown();
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_ShiftDown(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_ShiftDown",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)->ShiftDown();
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_CmdDown(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_CmdDown",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)->CmdDown();
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_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16755 bool result;
16756 PyObject * obj0 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "self", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",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 = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16767
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 {
16772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16773 }
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj;
16782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16783 bool result;
16784 PyObject * obj0 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16795
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 {
16800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16801 }
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16809 PyObject *resultobj;
16810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16811 bool result;
16812 PyObject * obj0 = 0 ;
16813 char *kwnames[] = {
16814 (char *) "self", NULL
16815 };
16816
16817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16819 if (SWIG_arg_fail(1)) SWIG_fail;
16820 {
16821 PyThreadState* __tstate = wxPyBeginAllowThreads();
16822 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16823
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 {
16828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16839 bool result;
16840 PyObject * obj0 = 0 ;
16841 char *kwnames[] = {
16842 (char *) "self", NULL
16843 };
16844
16845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 {
16856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16857 }
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj;
16866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16867 bool result;
16868 PyObject * obj0 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16879
16880 wxPyEndAllowThreads(__tstate);
16881 if (PyErr_Occurred()) SWIG_fail;
16882 }
16883 {
16884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16885 }
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj;
16894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16895 bool result;
16896 PyObject * obj0 = 0 ;
16897 char *kwnames[] = {
16898 (char *) "self", NULL
16899 };
16900
16901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16903 if (SWIG_arg_fail(1)) SWIG_fail;
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 {
16912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16913 }
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj;
16922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16923 bool result;
16924 PyObject * obj0 = 0 ;
16925 char *kwnames[] = {
16926 (char *) "self", NULL
16927 };
16928
16929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16931 if (SWIG_arg_fail(1)) SWIG_fail;
16932 {
16933 PyThreadState* __tstate = wxPyBeginAllowThreads();
16934 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16935
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 {
16940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16941 }
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16949 PyObject *resultobj;
16950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16951 bool result;
16952 PyObject * obj0 = 0 ;
16953 char *kwnames[] = {
16954 (char *) "self", NULL
16955 };
16956
16957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16959 if (SWIG_arg_fail(1)) SWIG_fail;
16960 {
16961 PyThreadState* __tstate = wxPyBeginAllowThreads();
16962 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16963
16964 wxPyEndAllowThreads(__tstate);
16965 if (PyErr_Occurred()) SWIG_fail;
16966 }
16967 {
16968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16969 }
16970 return resultobj;
16971 fail:
16972 return NULL;
16973 }
16974
16975
16976 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16977 PyObject *resultobj;
16978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16979 bool result;
16980 PyObject * obj0 = 0 ;
16981 char *kwnames[] = {
16982 (char *) "self", NULL
16983 };
16984
16985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16987 if (SWIG_arg_fail(1)) SWIG_fail;
16988 {
16989 PyThreadState* __tstate = wxPyBeginAllowThreads();
16990 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16991
16992 wxPyEndAllowThreads(__tstate);
16993 if (PyErr_Occurred()) SWIG_fail;
16994 }
16995 {
16996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16997 }
16998 return resultobj;
16999 fail:
17000 return NULL;
17001 }
17002
17003
17004 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17005 PyObject *resultobj;
17006 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17007 bool result;
17008 PyObject * obj0 = 0 ;
17009 char *kwnames[] = {
17010 (char *) "self", NULL
17011 };
17012
17013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17015 if (SWIG_arg_fail(1)) SWIG_fail;
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 result = (bool)(arg1)->LeftIsDown();
17019
17020 wxPyEndAllowThreads(__tstate);
17021 if (PyErr_Occurred()) SWIG_fail;
17022 }
17023 {
17024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17025 }
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17035 bool result;
17036 PyObject * obj0 = 0 ;
17037 char *kwnames[] = {
17038 (char *) "self", NULL
17039 };
17040
17041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17043 if (SWIG_arg_fail(1)) SWIG_fail;
17044 {
17045 PyThreadState* __tstate = wxPyBeginAllowThreads();
17046 result = (bool)(arg1)->MiddleIsDown();
17047
17048 wxPyEndAllowThreads(__tstate);
17049 if (PyErr_Occurred()) SWIG_fail;
17050 }
17051 {
17052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17053 }
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj;
17062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17063 bool result;
17064 PyObject * obj0 = 0 ;
17065 char *kwnames[] = {
17066 (char *) "self", NULL
17067 };
17068
17069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17071 if (SWIG_arg_fail(1)) SWIG_fail;
17072 {
17073 PyThreadState* __tstate = wxPyBeginAllowThreads();
17074 result = (bool)(arg1)->RightIsDown();
17075
17076 wxPyEndAllowThreads(__tstate);
17077 if (PyErr_Occurred()) SWIG_fail;
17078 }
17079 {
17080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17081 }
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17089 PyObject *resultobj;
17090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17091 bool result;
17092 PyObject * obj0 = 0 ;
17093 char *kwnames[] = {
17094 (char *) "self", NULL
17095 };
17096
17097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17099 if (SWIG_arg_fail(1)) SWIG_fail;
17100 {
17101 PyThreadState* __tstate = wxPyBeginAllowThreads();
17102 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17103
17104 wxPyEndAllowThreads(__tstate);
17105 if (PyErr_Occurred()) SWIG_fail;
17106 }
17107 {
17108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17109 }
17110 return resultobj;
17111 fail:
17112 return NULL;
17113 }
17114
17115
17116 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17117 PyObject *resultobj;
17118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17119 bool result;
17120 PyObject * obj0 = 0 ;
17121 char *kwnames[] = {
17122 (char *) "self", NULL
17123 };
17124
17125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17127 if (SWIG_arg_fail(1)) SWIG_fail;
17128 {
17129 PyThreadState* __tstate = wxPyBeginAllowThreads();
17130 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17131
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17137 }
17138 return resultobj;
17139 fail:
17140 return NULL;
17141 }
17142
17143
17144 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17145 PyObject *resultobj;
17146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17147 bool result;
17148 PyObject * obj0 = 0 ;
17149 char *kwnames[] = {
17150 (char *) "self", NULL
17151 };
17152
17153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17155 if (SWIG_arg_fail(1)) SWIG_fail;
17156 {
17157 PyThreadState* __tstate = wxPyBeginAllowThreads();
17158 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17159
17160 wxPyEndAllowThreads(__tstate);
17161 if (PyErr_Occurred()) SWIG_fail;
17162 }
17163 {
17164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17165 }
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj;
17174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17175 bool result;
17176 PyObject * obj0 = 0 ;
17177 char *kwnames[] = {
17178 (char *) "self", NULL
17179 };
17180
17181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17183 if (SWIG_arg_fail(1)) SWIG_fail;
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17187
17188 wxPyEndAllowThreads(__tstate);
17189 if (PyErr_Occurred()) SWIG_fail;
17190 }
17191 {
17192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17193 }
17194 return resultobj;
17195 fail:
17196 return NULL;
17197 }
17198
17199
17200 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17201 PyObject *resultobj;
17202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17203 wxPoint result;
17204 PyObject * obj0 = 0 ;
17205 char *kwnames[] = {
17206 (char *) "self", NULL
17207 };
17208
17209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",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 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (arg1)->GetPosition();
17215
17216 wxPyEndAllowThreads(__tstate);
17217 if (PyErr_Occurred()) SWIG_fail;
17218 }
17219 {
17220 wxPoint * resultptr;
17221 resultptr = new wxPoint((wxPoint &)(result));
17222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17223 }
17224 return resultobj;
17225 fail:
17226 return NULL;
17227 }
17228
17229
17230 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17231 PyObject *resultobj;
17232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17233 long *arg2 = (long *) 0 ;
17234 long *arg3 = (long *) 0 ;
17235 long temp2 ;
17236 int res2 = 0 ;
17237 long temp3 ;
17238 int res3 = 0 ;
17239 PyObject * obj0 = 0 ;
17240 char *kwnames[] = {
17241 (char *) "self", NULL
17242 };
17243
17244 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17245 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17248 if (SWIG_arg_fail(1)) SWIG_fail;
17249 {
17250 PyThreadState* __tstate = wxPyBeginAllowThreads();
17251 (arg1)->GetPosition(arg2,arg3);
17252
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 Py_INCREF(Py_None); resultobj = Py_None;
17257 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17258 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17259 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17260 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj;
17269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17270 wxDC *arg2 = 0 ;
17271 wxPoint result;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 char *kwnames[] = {
17275 (char *) "self",(char *) "dc", NULL
17276 };
17277
17278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17280 if (SWIG_arg_fail(1)) SWIG_fail;
17281 {
17282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17283 if (SWIG_arg_fail(2)) SWIG_fail;
17284 if (arg2 == NULL) {
17285 SWIG_null_ref("wxDC");
17286 }
17287 if (SWIG_arg_fail(2)) SWIG_fail;
17288 }
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17292
17293 wxPyEndAllowThreads(__tstate);
17294 if (PyErr_Occurred()) SWIG_fail;
17295 }
17296 {
17297 wxPoint * resultptr;
17298 resultptr = new wxPoint((wxPoint &)(result));
17299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17300 }
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj;
17309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17310 int result;
17311 PyObject * obj0 = 0 ;
17312 char *kwnames[] = {
17313 (char *) "self", NULL
17314 };
17315
17316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17318 if (SWIG_arg_fail(1)) SWIG_fail;
17319 {
17320 PyThreadState* __tstate = wxPyBeginAllowThreads();
17321 result = (int)((wxMouseEvent const *)arg1)->GetX();
17322
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 {
17327 resultobj = SWIG_From_int((int)(result));
17328 }
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj;
17337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17338 int result;
17339 PyObject * obj0 = 0 ;
17340 char *kwnames[] = {
17341 (char *) "self", NULL
17342 };
17343
17344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17346 if (SWIG_arg_fail(1)) SWIG_fail;
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (int)((wxMouseEvent const *)arg1)->GetY();
17350
17351 wxPyEndAllowThreads(__tstate);
17352 if (PyErr_Occurred()) SWIG_fail;
17353 }
17354 {
17355 resultobj = SWIG_From_int((int)(result));
17356 }
17357 return resultobj;
17358 fail:
17359 return NULL;
17360 }
17361
17362
17363 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17364 PyObject *resultobj;
17365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17366 int result;
17367 PyObject * obj0 = 0 ;
17368 char *kwnames[] = {
17369 (char *) "self", NULL
17370 };
17371
17372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17374 if (SWIG_arg_fail(1)) SWIG_fail;
17375 {
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17378
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 {
17383 resultobj = SWIG_From_int((int)(result));
17384 }
17385 return resultobj;
17386 fail:
17387 return NULL;
17388 }
17389
17390
17391 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj;
17393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17394 int result;
17395 PyObject * obj0 = 0 ;
17396 char *kwnames[] = {
17397 (char *) "self", NULL
17398 };
17399
17400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17402 if (SWIG_arg_fail(1)) SWIG_fail;
17403 {
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17406
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = SWIG_From_int((int)(result));
17412 }
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17420 PyObject *resultobj;
17421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17422 int result;
17423 PyObject * obj0 = 0 ;
17424 char *kwnames[] = {
17425 (char *) "self", NULL
17426 };
17427
17428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17430 if (SWIG_arg_fail(1)) SWIG_fail;
17431 {
17432 PyThreadState* __tstate = wxPyBeginAllowThreads();
17433 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17434
17435 wxPyEndAllowThreads(__tstate);
17436 if (PyErr_Occurred()) SWIG_fail;
17437 }
17438 {
17439 resultobj = SWIG_From_int((int)(result));
17440 }
17441 return resultobj;
17442 fail:
17443 return NULL;
17444 }
17445
17446
17447 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17448 PyObject *resultobj;
17449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17450 bool result;
17451 PyObject * obj0 = 0 ;
17452 char *kwnames[] = {
17453 (char *) "self", NULL
17454 };
17455
17456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17458 if (SWIG_arg_fail(1)) SWIG_fail;
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17462
17463 wxPyEndAllowThreads(__tstate);
17464 if (PyErr_Occurred()) SWIG_fail;
17465 }
17466 {
17467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17468 }
17469 return resultobj;
17470 fail:
17471 return NULL;
17472 }
17473
17474
17475 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17476 PyObject *resultobj;
17477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17478 int arg2 ;
17479 PyObject * obj0 = 0 ;
17480 PyObject * obj1 = 0 ;
17481 char *kwnames[] = {
17482 (char *) "self",(char *) "m_x", NULL
17483 };
17484
17485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17487 if (SWIG_arg_fail(1)) SWIG_fail;
17488 {
17489 arg2 = (int)(SWIG_As_int(obj1));
17490 if (SWIG_arg_fail(2)) SWIG_fail;
17491 }
17492 if (arg1) (arg1)->m_x = arg2;
17493
17494 Py_INCREF(Py_None); resultobj = Py_None;
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17504 int result;
17505 PyObject * obj0 = 0 ;
17506 char *kwnames[] = {
17507 (char *) "self", NULL
17508 };
17509
17510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17512 if (SWIG_arg_fail(1)) SWIG_fail;
17513 result = (int) ((arg1)->m_x);
17514
17515 {
17516 resultobj = SWIG_From_int((int)(result));
17517 }
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17525 PyObject *resultobj;
17526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17527 int arg2 ;
17528 PyObject * obj0 = 0 ;
17529 PyObject * obj1 = 0 ;
17530 char *kwnames[] = {
17531 (char *) "self",(char *) "m_y", NULL
17532 };
17533
17534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17536 if (SWIG_arg_fail(1)) SWIG_fail;
17537 {
17538 arg2 = (int)(SWIG_As_int(obj1));
17539 if (SWIG_arg_fail(2)) SWIG_fail;
17540 }
17541 if (arg1) (arg1)->m_y = arg2;
17542
17543 Py_INCREF(Py_None); resultobj = Py_None;
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17553 int result;
17554 PyObject * obj0 = 0 ;
17555 char *kwnames[] = {
17556 (char *) "self", NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(1)) SWIG_fail;
17562 result = (int) ((arg1)->m_y);
17563
17564 {
17565 resultobj = SWIG_From_int((int)(result));
17566 }
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj;
17575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17576 bool arg2 ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 char *kwnames[] = {
17580 (char *) "self",(char *) "m_leftDown", NULL
17581 };
17582
17583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17585 if (SWIG_arg_fail(1)) SWIG_fail;
17586 {
17587 arg2 = (bool)(SWIG_As_bool(obj1));
17588 if (SWIG_arg_fail(2)) SWIG_fail;
17589 }
17590 if (arg1) (arg1)->m_leftDown = arg2;
17591
17592 Py_INCREF(Py_None); resultobj = Py_None;
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj;
17601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17602 bool result;
17603 PyObject * obj0 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 result = (bool) ((arg1)->m_leftDown);
17612
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj;
17624 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17625 bool arg2 ;
17626 PyObject * obj0 = 0 ;
17627 PyObject * obj1 = 0 ;
17628 char *kwnames[] = {
17629 (char *) "self",(char *) "m_middleDown", NULL
17630 };
17631
17632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17634 if (SWIG_arg_fail(1)) SWIG_fail;
17635 {
17636 arg2 = (bool)(SWIG_As_bool(obj1));
17637 if (SWIG_arg_fail(2)) SWIG_fail;
17638 }
17639 if (arg1) (arg1)->m_middleDown = arg2;
17640
17641 Py_INCREF(Py_None); resultobj = Py_None;
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17649 PyObject *resultobj;
17650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17651 bool result;
17652 PyObject * obj0 = 0 ;
17653 char *kwnames[] = {
17654 (char *) "self", NULL
17655 };
17656
17657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17659 if (SWIG_arg_fail(1)) SWIG_fail;
17660 result = (bool) ((arg1)->m_middleDown);
17661
17662 {
17663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17664 }
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj;
17673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17674 bool arg2 ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self",(char *) "m_rightDown", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 arg2 = (bool)(SWIG_As_bool(obj1));
17686 if (SWIG_arg_fail(2)) SWIG_fail;
17687 }
17688 if (arg1) (arg1)->m_rightDown = arg2;
17689
17690 Py_INCREF(Py_None); resultobj = Py_None;
17691 return resultobj;
17692 fail:
17693 return NULL;
17694 }
17695
17696
17697 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17698 PyObject *resultobj;
17699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17700 bool result;
17701 PyObject * obj0 = 0 ;
17702 char *kwnames[] = {
17703 (char *) "self", NULL
17704 };
17705
17706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(1)) SWIG_fail;
17709 result = (bool) ((arg1)->m_rightDown);
17710
17711 {
17712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj;
17722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17723 bool arg2 ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 char *kwnames[] = {
17727 (char *) "self",(char *) "m_controlDown", NULL
17728 };
17729
17730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17732 if (SWIG_arg_fail(1)) SWIG_fail;
17733 {
17734 arg2 = (bool)(SWIG_As_bool(obj1));
17735 if (SWIG_arg_fail(2)) SWIG_fail;
17736 }
17737 if (arg1) (arg1)->m_controlDown = arg2;
17738
17739 Py_INCREF(Py_None); resultobj = Py_None;
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj;
17748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17749 bool result;
17750 PyObject * obj0 = 0 ;
17751 char *kwnames[] = {
17752 (char *) "self", NULL
17753 };
17754
17755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17757 if (SWIG_arg_fail(1)) SWIG_fail;
17758 result = (bool) ((arg1)->m_controlDown);
17759
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17772 bool arg2 ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char *kwnames[] = {
17776 (char *) "self",(char *) "m_shiftDown", NULL
17777 };
17778
17779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 {
17783 arg2 = (bool)(SWIG_As_bool(obj1));
17784 if (SWIG_arg_fail(2)) SWIG_fail;
17785 }
17786 if (arg1) (arg1)->m_shiftDown = arg2;
17787
17788 Py_INCREF(Py_None); resultobj = Py_None;
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj;
17797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17798 bool result;
17799 PyObject * obj0 = 0 ;
17800 char *kwnames[] = {
17801 (char *) "self", NULL
17802 };
17803
17804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17806 if (SWIG_arg_fail(1)) SWIG_fail;
17807 result = (bool) ((arg1)->m_shiftDown);
17808
17809 {
17810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17811 }
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17821 bool arg2 ;
17822 PyObject * obj0 = 0 ;
17823 PyObject * obj1 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "self",(char *) "m_altDown", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 {
17832 arg2 = (bool)(SWIG_As_bool(obj1));
17833 if (SWIG_arg_fail(2)) SWIG_fail;
17834 }
17835 if (arg1) (arg1)->m_altDown = arg2;
17836
17837 Py_INCREF(Py_None); resultobj = Py_None;
17838 return resultobj;
17839 fail:
17840 return NULL;
17841 }
17842
17843
17844 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17845 PyObject *resultobj;
17846 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17847 bool result;
17848 PyObject * obj0 = 0 ;
17849 char *kwnames[] = {
17850 (char *) "self", NULL
17851 };
17852
17853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17855 if (SWIG_arg_fail(1)) SWIG_fail;
17856 result = (bool) ((arg1)->m_altDown);
17857
17858 {
17859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17860 }
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17868 PyObject *resultobj;
17869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17870 bool arg2 ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 char *kwnames[] = {
17874 (char *) "self",(char *) "m_metaDown", NULL
17875 };
17876
17877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17879 if (SWIG_arg_fail(1)) SWIG_fail;
17880 {
17881 arg2 = (bool)(SWIG_As_bool(obj1));
17882 if (SWIG_arg_fail(2)) SWIG_fail;
17883 }
17884 if (arg1) (arg1)->m_metaDown = arg2;
17885
17886 Py_INCREF(Py_None); resultobj = Py_None;
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj;
17895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17896 bool result;
17897 PyObject * obj0 = 0 ;
17898 char *kwnames[] = {
17899 (char *) "self", NULL
17900 };
17901
17902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17904 if (SWIG_arg_fail(1)) SWIG_fail;
17905 result = (bool) ((arg1)->m_metaDown);
17906
17907 {
17908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17917 PyObject *resultobj;
17918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17919 int arg2 ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 char *kwnames[] = {
17923 (char *) "self",(char *) "m_wheelRotation", NULL
17924 };
17925
17926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17928 if (SWIG_arg_fail(1)) SWIG_fail;
17929 {
17930 arg2 = (int)(SWIG_As_int(obj1));
17931 if (SWIG_arg_fail(2)) SWIG_fail;
17932 }
17933 if (arg1) (arg1)->m_wheelRotation = arg2;
17934
17935 Py_INCREF(Py_None); resultobj = Py_None;
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17943 PyObject *resultobj;
17944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17945 int result;
17946 PyObject * obj0 = 0 ;
17947 char *kwnames[] = {
17948 (char *) "self", NULL
17949 };
17950
17951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17953 if (SWIG_arg_fail(1)) SWIG_fail;
17954 result = (int) ((arg1)->m_wheelRotation);
17955
17956 {
17957 resultobj = SWIG_From_int((int)(result));
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17968 int arg2 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char *kwnames[] = {
17972 (char *) "self",(char *) "m_wheelDelta", NULL
17973 };
17974
17975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17977 if (SWIG_arg_fail(1)) SWIG_fail;
17978 {
17979 arg2 = (int)(SWIG_As_int(obj1));
17980 if (SWIG_arg_fail(2)) SWIG_fail;
17981 }
17982 if (arg1) (arg1)->m_wheelDelta = arg2;
17983
17984 Py_INCREF(Py_None); resultobj = Py_None;
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj;
17993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17994 int result;
17995 PyObject * obj0 = 0 ;
17996 char *kwnames[] = {
17997 (char *) "self", NULL
17998 };
17999
18000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18002 if (SWIG_arg_fail(1)) SWIG_fail;
18003 result = (int) ((arg1)->m_wheelDelta);
18004
18005 {
18006 resultobj = SWIG_From_int((int)(result));
18007 }
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj;
18016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18017 int arg2 ;
18018 PyObject * obj0 = 0 ;
18019 PyObject * obj1 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "self",(char *) "m_linesPerAction", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 arg2 = (int)(SWIG_As_int(obj1));
18029 if (SWIG_arg_fail(2)) SWIG_fail;
18030 }
18031 if (arg1) (arg1)->m_linesPerAction = arg2;
18032
18033 Py_INCREF(Py_None); resultobj = Py_None;
18034 return resultobj;
18035 fail:
18036 return NULL;
18037 }
18038
18039
18040 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj;
18042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18043 int result;
18044 PyObject * obj0 = 0 ;
18045 char *kwnames[] = {
18046 (char *) "self", NULL
18047 };
18048
18049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18051 if (SWIG_arg_fail(1)) SWIG_fail;
18052 result = (int) ((arg1)->m_linesPerAction);
18053
18054 {
18055 resultobj = SWIG_From_int((int)(result));
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18064 PyObject *obj;
18065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18066 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18067 Py_INCREF(obj);
18068 return Py_BuildValue((char *)"");
18069 }
18070 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj;
18072 int arg1 = (int) 0 ;
18073 int arg2 = (int) 0 ;
18074 wxSetCursorEvent *result;
18075 PyObject * obj0 = 0 ;
18076 PyObject * obj1 = 0 ;
18077 char *kwnames[] = {
18078 (char *) "x",(char *) "y", NULL
18079 };
18080
18081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18082 if (obj0) {
18083 {
18084 arg1 = (int)(SWIG_As_int(obj0));
18085 if (SWIG_arg_fail(1)) SWIG_fail;
18086 }
18087 }
18088 if (obj1) {
18089 {
18090 arg2 = (int)(SWIG_As_int(obj1));
18091 if (SWIG_arg_fail(2)) SWIG_fail;
18092 }
18093 }
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18097
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18109 PyObject *resultobj;
18110 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18111 int result;
18112 PyObject * obj0 = 0 ;
18113 char *kwnames[] = {
18114 (char *) "self", NULL
18115 };
18116
18117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18119 if (SWIG_arg_fail(1)) SWIG_fail;
18120 {
18121 PyThreadState* __tstate = wxPyBeginAllowThreads();
18122 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18123
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 {
18128 resultobj = SWIG_From_int((int)(result));
18129 }
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj;
18138 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18139 int result;
18140 PyObject * obj0 = 0 ;
18141 char *kwnames[] = {
18142 (char *) "self", NULL
18143 };
18144
18145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18147 if (SWIG_arg_fail(1)) SWIG_fail;
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18151
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 {
18156 resultobj = SWIG_From_int((int)(result));
18157 }
18158 return resultobj;
18159 fail:
18160 return NULL;
18161 }
18162
18163
18164 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18165 PyObject *resultobj;
18166 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18167 wxCursor *arg2 = 0 ;
18168 PyObject * obj0 = 0 ;
18169 PyObject * obj1 = 0 ;
18170 char *kwnames[] = {
18171 (char *) "self",(char *) "cursor", NULL
18172 };
18173
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18179 if (SWIG_arg_fail(2)) SWIG_fail;
18180 if (arg2 == NULL) {
18181 SWIG_null_ref("wxCursor");
18182 }
18183 if (SWIG_arg_fail(2)) SWIG_fail;
18184 }
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 (arg1)->SetCursor((wxCursor const &)*arg2);
18188
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 Py_INCREF(Py_None); resultobj = Py_None;
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18200 PyObject *resultobj;
18201 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18202 wxCursor *result;
18203 PyObject * obj0 = 0 ;
18204 char *kwnames[] = {
18205 (char *) "self", NULL
18206 };
18207
18208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18210 if (SWIG_arg_fail(1)) SWIG_fail;
18211 {
18212 PyThreadState* __tstate = wxPyBeginAllowThreads();
18213 {
18214 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18215 result = (wxCursor *) &_result_ref;
18216 }
18217
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 {
18222 wxCursor* resultptr = new wxCursor(*result);
18223 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18224 }
18225 return resultobj;
18226 fail:
18227 return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj;
18233 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18234 bool result;
18235 PyObject * obj0 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18246
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 {
18251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18252 }
18253 return resultobj;
18254 fail:
18255 return NULL;
18256 }
18257
18258
18259 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18260 PyObject *obj;
18261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18262 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18263 Py_INCREF(obj);
18264 return Py_BuildValue((char *)"");
18265 }
18266 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj;
18268 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18269 wxKeyEvent *result;
18270 PyObject * obj0 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "keyType", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18276 if (obj0) {
18277 {
18278 arg1 = (wxEventType)(SWIG_As_int(obj0));
18279 if (SWIG_arg_fail(1)) SWIG_fail;
18280 }
18281 }
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18290 return resultobj;
18291 fail:
18292 return NULL;
18293 }
18294
18295
18296 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18297 PyObject *resultobj;
18298 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18299 bool result;
18300 PyObject * obj0 = 0 ;
18301 char *kwnames[] = {
18302 (char *) "self", NULL
18303 };
18304
18305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18307 if (SWIG_arg_fail(1)) SWIG_fail;
18308 {
18309 PyThreadState* __tstate = wxPyBeginAllowThreads();
18310 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18311
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 {
18316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18317 }
18318 return resultobj;
18319 fail:
18320 return NULL;
18321 }
18322
18323
18324 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18325 PyObject *resultobj;
18326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18327 bool result;
18328 PyObject * obj0 = 0 ;
18329 char *kwnames[] = {
18330 (char *) "self", NULL
18331 };
18332
18333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(1)) SWIG_fail;
18336 {
18337 PyThreadState* __tstate = wxPyBeginAllowThreads();
18338 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18339
18340 wxPyEndAllowThreads(__tstate);
18341 if (PyErr_Occurred()) SWIG_fail;
18342 }
18343 {
18344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18345 }
18346 return resultobj;
18347 fail:
18348 return NULL;
18349 }
18350
18351
18352 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18353 PyObject *resultobj;
18354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18355 bool result;
18356 PyObject * obj0 = 0 ;
18357 char *kwnames[] = {
18358 (char *) "self", NULL
18359 };
18360
18361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18363 if (SWIG_arg_fail(1)) SWIG_fail;
18364 {
18365 PyThreadState* __tstate = wxPyBeginAllowThreads();
18366 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18367
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 {
18372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18373 }
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18383 bool result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18395
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 {
18400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18401 }
18402 return resultobj;
18403 fail:
18404 return NULL;
18405 }
18406
18407
18408 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18409 PyObject *resultobj;
18410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18411 bool result;
18412 PyObject * obj0 = 0 ;
18413 char *kwnames[] = {
18414 (char *) "self", NULL
18415 };
18416
18417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18419 if (SWIG_arg_fail(1)) SWIG_fail;
18420 {
18421 PyThreadState* __tstate = wxPyBeginAllowThreads();
18422 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18423
18424 wxPyEndAllowThreads(__tstate);
18425 if (PyErr_Occurred()) SWIG_fail;
18426 }
18427 {
18428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18429 }
18430 return resultobj;
18431 fail:
18432 return NULL;
18433 }
18434
18435
18436 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18437 PyObject *resultobj;
18438 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18439 bool result;
18440 PyObject * obj0 = 0 ;
18441 char *kwnames[] = {
18442 (char *) "self", NULL
18443 };
18444
18445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18447 if (SWIG_arg_fail(1)) SWIG_fail;
18448 {
18449 PyThreadState* __tstate = wxPyBeginAllowThreads();
18450 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18451
18452 wxPyEndAllowThreads(__tstate);
18453 if (PyErr_Occurred()) SWIG_fail;
18454 }
18455 {
18456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18457 }
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18465 PyObject *resultobj;
18466 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18467 int result;
18468 PyObject * obj0 = 0 ;
18469 char *kwnames[] = {
18470 (char *) "self", NULL
18471 };
18472
18473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18475 if (SWIG_arg_fail(1)) SWIG_fail;
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18479
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 {
18484 resultobj = SWIG_From_int((int)(result));
18485 }
18486 return resultobj;
18487 fail:
18488 return NULL;
18489 }
18490
18491
18492 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18493 PyObject *resultobj;
18494 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18495 int result;
18496 PyObject * obj0 = 0 ;
18497 char *kwnames[] = {
18498 (char *) "self", NULL
18499 };
18500
18501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18503 if (SWIG_arg_fail(1)) SWIG_fail;
18504 {
18505 PyThreadState* __tstate = wxPyBeginAllowThreads();
18506 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18507
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 {
18512 resultobj = SWIG_From_int((int)(result));
18513 }
18514 return resultobj;
18515 fail:
18516 return NULL;
18517 }
18518
18519
18520 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18521 PyObject *resultobj;
18522 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18523 unsigned int result;
18524 PyObject * obj0 = 0 ;
18525 char *kwnames[] = {
18526 (char *) "self", NULL
18527 };
18528
18529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18531 if (SWIG_arg_fail(1)) SWIG_fail;
18532 {
18533 PyThreadState* __tstate = wxPyBeginAllowThreads();
18534 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18535
18536 wxPyEndAllowThreads(__tstate);
18537 if (PyErr_Occurred()) SWIG_fail;
18538 }
18539 {
18540 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18541 }
18542 return resultobj;
18543 fail:
18544 return NULL;
18545 }
18546
18547
18548 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18549 PyObject *resultobj;
18550 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18551 unsigned int result;
18552 PyObject * obj0 = 0 ;
18553 char *kwnames[] = {
18554 (char *) "self", NULL
18555 };
18556
18557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18559 if (SWIG_arg_fail(1)) SWIG_fail;
18560 {
18561 PyThreadState* __tstate = wxPyBeginAllowThreads();
18562 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18563
18564 wxPyEndAllowThreads(__tstate);
18565 if (PyErr_Occurred()) SWIG_fail;
18566 }
18567 {
18568 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18569 }
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj;
18578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18579 wxPoint result;
18580 PyObject * obj0 = 0 ;
18581 char *kwnames[] = {
18582 (char *) "self", NULL
18583 };
18584
18585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18587 if (SWIG_arg_fail(1)) SWIG_fail;
18588 {
18589 PyThreadState* __tstate = wxPyBeginAllowThreads();
18590 result = (arg1)->GetPosition();
18591
18592 wxPyEndAllowThreads(__tstate);
18593 if (PyErr_Occurred()) SWIG_fail;
18594 }
18595 {
18596 wxPoint * resultptr;
18597 resultptr = new wxPoint((wxPoint &)(result));
18598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18599 }
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj;
18608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18609 long *arg2 = (long *) 0 ;
18610 long *arg3 = (long *) 0 ;
18611 long temp2 ;
18612 int res2 = 0 ;
18613 long temp3 ;
18614 int res3 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 char *kwnames[] = {
18617 (char *) "self", NULL
18618 };
18619
18620 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18621 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18624 if (SWIG_arg_fail(1)) SWIG_fail;
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 (arg1)->GetPosition(arg2,arg3);
18628
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 Py_INCREF(Py_None); resultobj = Py_None;
18633 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18634 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18635 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18636 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18644 PyObject *resultobj;
18645 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18646 int result;
18647 PyObject * obj0 = 0 ;
18648 char *kwnames[] = {
18649 (char *) "self", NULL
18650 };
18651
18652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18654 if (SWIG_arg_fail(1)) SWIG_fail;
18655 {
18656 PyThreadState* __tstate = wxPyBeginAllowThreads();
18657 result = (int)((wxKeyEvent const *)arg1)->GetX();
18658
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 {
18663 resultobj = SWIG_From_int((int)(result));
18664 }
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj;
18673 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18674 int result;
18675 PyObject * obj0 = 0 ;
18676 char *kwnames[] = {
18677 (char *) "self", NULL
18678 };
18679
18680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18682 if (SWIG_arg_fail(1)) SWIG_fail;
18683 {
18684 PyThreadState* __tstate = wxPyBeginAllowThreads();
18685 result = (int)((wxKeyEvent const *)arg1)->GetY();
18686
18687 wxPyEndAllowThreads(__tstate);
18688 if (PyErr_Occurred()) SWIG_fail;
18689 }
18690 {
18691 resultobj = SWIG_From_int((int)(result));
18692 }
18693 return resultobj;
18694 fail:
18695 return NULL;
18696 }
18697
18698
18699 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18700 PyObject *resultobj;
18701 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18702 int arg2 ;
18703 PyObject * obj0 = 0 ;
18704 PyObject * obj1 = 0 ;
18705 char *kwnames[] = {
18706 (char *) "self",(char *) "m_x", NULL
18707 };
18708
18709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18711 if (SWIG_arg_fail(1)) SWIG_fail;
18712 {
18713 arg2 = (int)(SWIG_As_int(obj1));
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 }
18716 if (arg1) (arg1)->m_x = arg2;
18717
18718 Py_INCREF(Py_None); resultobj = Py_None;
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18726 PyObject *resultobj;
18727 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18728 int result;
18729 PyObject * obj0 = 0 ;
18730 char *kwnames[] = {
18731 (char *) "self", NULL
18732 };
18733
18734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18736 if (SWIG_arg_fail(1)) SWIG_fail;
18737 result = (int) ((arg1)->m_x);
18738
18739 {
18740 resultobj = SWIG_From_int((int)(result));
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj;
18750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18751 int arg2 ;
18752 PyObject * obj0 = 0 ;
18753 PyObject * obj1 = 0 ;
18754 char *kwnames[] = {
18755 (char *) "self",(char *) "m_y", NULL
18756 };
18757
18758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18760 if (SWIG_arg_fail(1)) SWIG_fail;
18761 {
18762 arg2 = (int)(SWIG_As_int(obj1));
18763 if (SWIG_arg_fail(2)) SWIG_fail;
18764 }
18765 if (arg1) (arg1)->m_y = arg2;
18766
18767 Py_INCREF(Py_None); resultobj = Py_None;
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18777 int result;
18778 PyObject * obj0 = 0 ;
18779 char *kwnames[] = {
18780 (char *) "self", NULL
18781 };
18782
18783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18785 if (SWIG_arg_fail(1)) SWIG_fail;
18786 result = (int) ((arg1)->m_y);
18787
18788 {
18789 resultobj = SWIG_From_int((int)(result));
18790 }
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj;
18799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18800 long arg2 ;
18801 PyObject * obj0 = 0 ;
18802 PyObject * obj1 = 0 ;
18803 char *kwnames[] = {
18804 (char *) "self",(char *) "m_keyCode", NULL
18805 };
18806
18807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18809 if (SWIG_arg_fail(1)) SWIG_fail;
18810 {
18811 arg2 = (long)(SWIG_As_long(obj1));
18812 if (SWIG_arg_fail(2)) SWIG_fail;
18813 }
18814 if (arg1) (arg1)->m_keyCode = arg2;
18815
18816 Py_INCREF(Py_None); resultobj = Py_None;
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj;
18825 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18826 long result;
18827 PyObject * obj0 = 0 ;
18828 char *kwnames[] = {
18829 (char *) "self", NULL
18830 };
18831
18832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18834 if (SWIG_arg_fail(1)) SWIG_fail;
18835 result = (long) ((arg1)->m_keyCode);
18836
18837 {
18838 resultobj = SWIG_From_long((long)(result));
18839 }
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj;
18848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18849 bool arg2 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char *kwnames[] = {
18853 (char *) "self",(char *) "m_controlDown", NULL
18854 };
18855
18856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18858 if (SWIG_arg_fail(1)) SWIG_fail;
18859 {
18860 arg2 = (bool)(SWIG_As_bool(obj1));
18861 if (SWIG_arg_fail(2)) SWIG_fail;
18862 }
18863 if (arg1) (arg1)->m_controlDown = arg2;
18864
18865 Py_INCREF(Py_None); resultobj = Py_None;
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj;
18874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18875 bool result;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 result = (bool) ((arg1)->m_controlDown);
18885
18886 {
18887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18898 bool arg2 ;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "self",(char *) "m_shiftDown", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 arg2 = (bool)(SWIG_As_bool(obj1));
18910 if (SWIG_arg_fail(2)) SWIG_fail;
18911 }
18912 if (arg1) (arg1)->m_shiftDown = arg2;
18913
18914 Py_INCREF(Py_None); resultobj = Py_None;
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj;
18923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18924 bool result;
18925 PyObject * obj0 = 0 ;
18926 char *kwnames[] = {
18927 (char *) "self", NULL
18928 };
18929
18930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18932 if (SWIG_arg_fail(1)) SWIG_fail;
18933 result = (bool) ((arg1)->m_shiftDown);
18934
18935 {
18936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18937 }
18938 return resultobj;
18939 fail:
18940 return NULL;
18941 }
18942
18943
18944 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18945 PyObject *resultobj;
18946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18947 bool arg2 ;
18948 PyObject * obj0 = 0 ;
18949 PyObject * obj1 = 0 ;
18950 char *kwnames[] = {
18951 (char *) "self",(char *) "m_altDown", NULL
18952 };
18953
18954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18956 if (SWIG_arg_fail(1)) SWIG_fail;
18957 {
18958 arg2 = (bool)(SWIG_As_bool(obj1));
18959 if (SWIG_arg_fail(2)) SWIG_fail;
18960 }
18961 if (arg1) (arg1)->m_altDown = arg2;
18962
18963 Py_INCREF(Py_None); resultobj = Py_None;
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18971 PyObject *resultobj;
18972 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18973 bool result;
18974 PyObject * obj0 = 0 ;
18975 char *kwnames[] = {
18976 (char *) "self", NULL
18977 };
18978
18979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(1)) SWIG_fail;
18982 result = (bool) ((arg1)->m_altDown);
18983
18984 {
18985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18986 }
18987 return resultobj;
18988 fail:
18989 return NULL;
18990 }
18991
18992
18993 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj;
18995 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18996 bool arg2 ;
18997 PyObject * obj0 = 0 ;
18998 PyObject * obj1 = 0 ;
18999 char *kwnames[] = {
19000 (char *) "self",(char *) "m_metaDown", NULL
19001 };
19002
19003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19005 if (SWIG_arg_fail(1)) SWIG_fail;
19006 {
19007 arg2 = (bool)(SWIG_As_bool(obj1));
19008 if (SWIG_arg_fail(2)) SWIG_fail;
19009 }
19010 if (arg1) (arg1)->m_metaDown = arg2;
19011
19012 Py_INCREF(Py_None); resultobj = Py_None;
19013 return resultobj;
19014 fail:
19015 return NULL;
19016 }
19017
19018
19019 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj;
19021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19022 bool result;
19023 PyObject * obj0 = 0 ;
19024 char *kwnames[] = {
19025 (char *) "self", NULL
19026 };
19027
19028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19030 if (SWIG_arg_fail(1)) SWIG_fail;
19031 result = (bool) ((arg1)->m_metaDown);
19032
19033 {
19034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19035 }
19036 return resultobj;
19037 fail:
19038 return NULL;
19039 }
19040
19041
19042 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19043 PyObject *resultobj;
19044 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19045 bool arg2 ;
19046 PyObject * obj0 = 0 ;
19047 PyObject * obj1 = 0 ;
19048 char *kwnames[] = {
19049 (char *) "self",(char *) "m_scanCode", NULL
19050 };
19051
19052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19054 if (SWIG_arg_fail(1)) SWIG_fail;
19055 {
19056 arg2 = (bool)(SWIG_As_bool(obj1));
19057 if (SWIG_arg_fail(2)) SWIG_fail;
19058 }
19059 if (arg1) (arg1)->m_scanCode = arg2;
19060
19061 Py_INCREF(Py_None); resultobj = Py_None;
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj;
19070 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19071 bool result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "self", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19079 if (SWIG_arg_fail(1)) SWIG_fail;
19080 result = (bool) ((arg1)->m_scanCode);
19081
19082 {
19083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19084 }
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj;
19093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19094 unsigned int arg2 ;
19095 PyObject * obj0 = 0 ;
19096 PyObject * obj1 = 0 ;
19097 char *kwnames[] = {
19098 (char *) "self",(char *) "m_rawCode", NULL
19099 };
19100
19101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19103 if (SWIG_arg_fail(1)) SWIG_fail;
19104 {
19105 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19106 if (SWIG_arg_fail(2)) SWIG_fail;
19107 }
19108 if (arg1) (arg1)->m_rawCode = arg2;
19109
19110 Py_INCREF(Py_None); resultobj = Py_None;
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19120 unsigned int result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "self", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19128 if (SWIG_arg_fail(1)) SWIG_fail;
19129 result = (unsigned int) ((arg1)->m_rawCode);
19130
19131 {
19132 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19133 }
19134 return resultobj;
19135 fail:
19136 return NULL;
19137 }
19138
19139
19140 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj;
19142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19143 unsigned int arg2 ;
19144 PyObject * obj0 = 0 ;
19145 PyObject * obj1 = 0 ;
19146 char *kwnames[] = {
19147 (char *) "self",(char *) "m_rawFlags", NULL
19148 };
19149
19150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 {
19154 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19155 if (SWIG_arg_fail(2)) SWIG_fail;
19156 }
19157 if (arg1) (arg1)->m_rawFlags = arg2;
19158
19159 Py_INCREF(Py_None); resultobj = Py_None;
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj;
19168 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19169 unsigned int result;
19170 PyObject * obj0 = 0 ;
19171 char *kwnames[] = {
19172 (char *) "self", NULL
19173 };
19174
19175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19177 if (SWIG_arg_fail(1)) SWIG_fail;
19178 result = (unsigned int) ((arg1)->m_rawFlags);
19179
19180 {
19181 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19182 }
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19190 PyObject *obj;
19191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19192 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19193 Py_INCREF(obj);
19194 return Py_BuildValue((char *)"");
19195 }
19196 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj;
19198 wxSize const &arg1_defvalue = wxDefaultSize ;
19199 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19200 int arg2 = (int) 0 ;
19201 wxSizeEvent *result;
19202 wxSize temp1 ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char *kwnames[] = {
19206 (char *) "sz",(char *) "winid", NULL
19207 };
19208
19209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19210 if (obj0) {
19211 {
19212 arg1 = &temp1;
19213 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19214 }
19215 }
19216 if (obj1) {
19217 {
19218 arg2 = (int)(SWIG_As_int(obj1));
19219 if (SWIG_arg_fail(2)) SWIG_fail;
19220 }
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19225
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj;
19238 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19239 wxSize result;
19240 PyObject * obj0 = 0 ;
19241 char *kwnames[] = {
19242 (char *) "self", NULL
19243 };
19244
19245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19247 if (SWIG_arg_fail(1)) SWIG_fail;
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = ((wxSizeEvent const *)arg1)->GetSize();
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 wxSize * resultptr;
19257 resultptr = new wxSize((wxSize &)(result));
19258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj;
19268 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19269 wxRect result;
19270 PyObject * obj0 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "self", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19277 if (SWIG_arg_fail(1)) SWIG_fail;
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 result = ((wxSizeEvent const *)arg1)->GetRect();
19281
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 wxRect * resultptr;
19287 resultptr = new wxRect((wxRect &)(result));
19288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19289 }
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19297 PyObject *resultobj;
19298 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19299 wxRect arg2 ;
19300 PyObject * obj0 = 0 ;
19301 PyObject * obj1 = 0 ;
19302 char *kwnames[] = {
19303 (char *) "self",(char *) "rect", NULL
19304 };
19305
19306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19308 if (SWIG_arg_fail(1)) SWIG_fail;
19309 {
19310 wxRect * argp;
19311 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19312 if (SWIG_arg_fail(2)) SWIG_fail;
19313 if (argp == NULL) {
19314 SWIG_null_ref("wxRect");
19315 }
19316 if (SWIG_arg_fail(2)) SWIG_fail;
19317 arg2 = *argp;
19318 }
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 (arg1)->SetRect(arg2);
19322
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 Py_INCREF(Py_None); resultobj = Py_None;
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj;
19335 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19336 wxSize arg2 ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "self",(char *) "size", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 {
19347 wxSize * argp;
19348 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19349 if (SWIG_arg_fail(2)) SWIG_fail;
19350 if (argp == NULL) {
19351 SWIG_null_ref("wxSize");
19352 }
19353 if (SWIG_arg_fail(2)) SWIG_fail;
19354 arg2 = *argp;
19355 }
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 wxSizeEvent_SetSize(arg1,arg2);
19359
19360 wxPyEndAllowThreads(__tstate);
19361 if (PyErr_Occurred()) SWIG_fail;
19362 }
19363 Py_INCREF(Py_None); resultobj = Py_None;
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19371 PyObject *resultobj;
19372 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19373 wxSize *arg2 = (wxSize *) 0 ;
19374 PyObject * obj0 = 0 ;
19375 PyObject * obj1 = 0 ;
19376 char *kwnames[] = {
19377 (char *) "self",(char *) "m_size", NULL
19378 };
19379
19380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19382 if (SWIG_arg_fail(1)) SWIG_fail;
19383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19384 if (SWIG_arg_fail(2)) SWIG_fail;
19385 if (arg1) (arg1)->m_size = *arg2;
19386
19387 Py_INCREF(Py_None); resultobj = Py_None;
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj;
19396 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19397 wxSize *result;
19398 PyObject * obj0 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "self", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19405 if (SWIG_arg_fail(1)) SWIG_fail;
19406 result = (wxSize *)& ((arg1)->m_size);
19407
19408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19409 return resultobj;
19410 fail:
19411 return NULL;
19412 }
19413
19414
19415 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj;
19417 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19418 wxRect *arg2 = (wxRect *) 0 ;
19419 PyObject * obj0 = 0 ;
19420 PyObject * obj1 = 0 ;
19421 char *kwnames[] = {
19422 (char *) "self",(char *) "m_rect", NULL
19423 };
19424
19425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19427 if (SWIG_arg_fail(1)) SWIG_fail;
19428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19429 if (SWIG_arg_fail(2)) SWIG_fail;
19430 if (arg1) (arg1)->m_rect = *arg2;
19431
19432 Py_INCREF(Py_None); resultobj = Py_None;
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19440 PyObject *resultobj;
19441 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19442 wxRect *result;
19443 PyObject * obj0 = 0 ;
19444 char *kwnames[] = {
19445 (char *) "self", NULL
19446 };
19447
19448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19450 if (SWIG_arg_fail(1)) SWIG_fail;
19451 result = (wxRect *)& ((arg1)->m_rect);
19452
19453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19461 PyObject *obj;
19462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19463 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19464 Py_INCREF(obj);
19465 return Py_BuildValue((char *)"");
19466 }
19467 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj;
19469 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19470 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19471 int arg2 = (int) 0 ;
19472 wxMoveEvent *result;
19473 wxPoint temp1 ;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 char *kwnames[] = {
19477 (char *) "pos",(char *) "winid", NULL
19478 };
19479
19480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19481 if (obj0) {
19482 {
19483 arg1 = &temp1;
19484 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19485 }
19486 }
19487 if (obj1) {
19488 {
19489 arg2 = (int)(SWIG_As_int(obj1));
19490 if (SWIG_arg_fail(2)) SWIG_fail;
19491 }
19492 }
19493 {
19494 PyThreadState* __tstate = wxPyBeginAllowThreads();
19495 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19496
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19508 PyObject *resultobj;
19509 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19510 wxPoint result;
19511 PyObject * obj0 = 0 ;
19512 char *kwnames[] = {
19513 (char *) "self", NULL
19514 };
19515
19516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19518 if (SWIG_arg_fail(1)) SWIG_fail;
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = ((wxMoveEvent const *)arg1)->GetPosition();
19522
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 {
19527 wxPoint * resultptr;
19528 resultptr = new wxPoint((wxPoint &)(result));
19529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19530 }
19531 return resultobj;
19532 fail:
19533 return NULL;
19534 }
19535
19536
19537 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19538 PyObject *resultobj;
19539 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19540 wxRect result;
19541 PyObject * obj0 = 0 ;
19542 char *kwnames[] = {
19543 (char *) "self", NULL
19544 };
19545
19546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19548 if (SWIG_arg_fail(1)) SWIG_fail;
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 result = ((wxMoveEvent const *)arg1)->GetRect();
19552
19553 wxPyEndAllowThreads(__tstate);
19554 if (PyErr_Occurred()) SWIG_fail;
19555 }
19556 {
19557 wxRect * resultptr;
19558 resultptr = new wxRect((wxRect &)(result));
19559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19560 }
19561 return resultobj;
19562 fail:
19563 return NULL;
19564 }
19565
19566
19567 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj;
19569 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19570 wxRect *arg2 = 0 ;
19571 wxRect temp2 ;
19572 PyObject * obj0 = 0 ;
19573 PyObject * obj1 = 0 ;
19574 char *kwnames[] = {
19575 (char *) "self",(char *) "rect", NULL
19576 };
19577
19578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 {
19582 arg2 = &temp2;
19583 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 (arg1)->SetRect((wxRect const &)*arg2);
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 Py_INCREF(Py_None); resultobj = Py_None;
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19602 wxPoint *arg2 = 0 ;
19603 wxPoint temp2 ;
19604 PyObject * obj0 = 0 ;
19605 PyObject * obj1 = 0 ;
19606 char *kwnames[] = {
19607 (char *) "self",(char *) "pos", NULL
19608 };
19609
19610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19612 if (SWIG_arg_fail(1)) SWIG_fail;
19613 {
19614 arg2 = &temp2;
19615 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19616 }
19617 {
19618 PyThreadState* __tstate = wxPyBeginAllowThreads();
19619 (arg1)->SetPosition((wxPoint const &)*arg2);
19620
19621 wxPyEndAllowThreads(__tstate);
19622 if (PyErr_Occurred()) SWIG_fail;
19623 }
19624 Py_INCREF(Py_None); resultobj = Py_None;
19625 return resultobj;
19626 fail:
19627 return NULL;
19628 }
19629
19630
19631 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19632 PyObject *obj;
19633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19634 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19635 Py_INCREF(obj);
19636 return Py_BuildValue((char *)"");
19637 }
19638 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19639 PyObject *resultobj;
19640 int arg1 = (int) 0 ;
19641 wxPaintEvent *result;
19642 PyObject * obj0 = 0 ;
19643 char *kwnames[] = {
19644 (char *) "Id", NULL
19645 };
19646
19647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19648 if (obj0) {
19649 {
19650 arg1 = (int)(SWIG_As_int(obj0));
19651 if (SWIG_arg_fail(1)) SWIG_fail;
19652 }
19653 }
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19657
19658 wxPyEndAllowThreads(__tstate);
19659 if (PyErr_Occurred()) SWIG_fail;
19660 }
19661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19662 return resultobj;
19663 fail:
19664 return NULL;
19665 }
19666
19667
19668 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19669 PyObject *obj;
19670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19671 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19672 Py_INCREF(obj);
19673 return Py_BuildValue((char *)"");
19674 }
19675 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19676 PyObject *resultobj;
19677 int arg1 = (int) 0 ;
19678 wxNcPaintEvent *result;
19679 PyObject * obj0 = 0 ;
19680 char *kwnames[] = {
19681 (char *) "winid", NULL
19682 };
19683
19684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19685 if (obj0) {
19686 {
19687 arg1 = (int)(SWIG_As_int(obj0));
19688 if (SWIG_arg_fail(1)) SWIG_fail;
19689 }
19690 }
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19694
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19706 PyObject *obj;
19707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19708 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19709 Py_INCREF(obj);
19710 return Py_BuildValue((char *)"");
19711 }
19712 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19713 PyObject *resultobj;
19714 int arg1 = (int) 0 ;
19715 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19716 wxEraseEvent *result;
19717 PyObject * obj0 = 0 ;
19718 PyObject * obj1 = 0 ;
19719 char *kwnames[] = {
19720 (char *) "Id",(char *) "dc", NULL
19721 };
19722
19723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19724 if (obj0) {
19725 {
19726 arg1 = (int)(SWIG_As_int(obj0));
19727 if (SWIG_arg_fail(1)) SWIG_fail;
19728 }
19729 }
19730 if (obj1) {
19731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19732 if (SWIG_arg_fail(2)) SWIG_fail;
19733 }
19734 {
19735 PyThreadState* __tstate = wxPyBeginAllowThreads();
19736 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19737
19738 wxPyEndAllowThreads(__tstate);
19739 if (PyErr_Occurred()) SWIG_fail;
19740 }
19741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19742 return resultobj;
19743 fail:
19744 return NULL;
19745 }
19746
19747
19748 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19749 PyObject *resultobj;
19750 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19751 wxDC *result;
19752 PyObject * obj0 = 0 ;
19753 char *kwnames[] = {
19754 (char *) "self", NULL
19755 };
19756
19757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19759 if (SWIG_arg_fail(1)) SWIG_fail;
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19763
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 {
19768 resultobj = wxPyMake_wxObject(result, 0);
19769 }
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19777 PyObject *obj;
19778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19779 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19780 Py_INCREF(obj);
19781 return Py_BuildValue((char *)"");
19782 }
19783 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj;
19785 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19786 int arg2 = (int) 0 ;
19787 wxFocusEvent *result;
19788 PyObject * obj0 = 0 ;
19789 PyObject * obj1 = 0 ;
19790 char *kwnames[] = {
19791 (char *) "type",(char *) "winid", NULL
19792 };
19793
19794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19795 if (obj0) {
19796 {
19797 arg1 = (wxEventType)(SWIG_As_int(obj0));
19798 if (SWIG_arg_fail(1)) SWIG_fail;
19799 }
19800 }
19801 if (obj1) {
19802 {
19803 arg2 = (int)(SWIG_As_int(obj1));
19804 if (SWIG_arg_fail(2)) SWIG_fail;
19805 }
19806 }
19807 {
19808 PyThreadState* __tstate = wxPyBeginAllowThreads();
19809 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19810
19811 wxPyEndAllowThreads(__tstate);
19812 if (PyErr_Occurred()) SWIG_fail;
19813 }
19814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj;
19823 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19824 wxWindow *result;
19825 PyObject * obj0 = 0 ;
19826 char *kwnames[] = {
19827 (char *) "self", NULL
19828 };
19829
19830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19832 if (SWIG_arg_fail(1)) SWIG_fail;
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19836
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 {
19841 resultobj = wxPyMake_wxObject(result, 0);
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj;
19851 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19852 wxWindow *arg2 = (wxWindow *) 0 ;
19853 PyObject * obj0 = 0 ;
19854 PyObject * obj1 = 0 ;
19855 char *kwnames[] = {
19856 (char *) "self",(char *) "win", NULL
19857 };
19858
19859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19861 if (SWIG_arg_fail(1)) SWIG_fail;
19862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19863 if (SWIG_arg_fail(2)) SWIG_fail;
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 (arg1)->SetWindow(arg2);
19867
19868 wxPyEndAllowThreads(__tstate);
19869 if (PyErr_Occurred()) SWIG_fail;
19870 }
19871 Py_INCREF(Py_None); resultobj = Py_None;
19872 return resultobj;
19873 fail:
19874 return NULL;
19875 }
19876
19877
19878 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19879 PyObject *obj;
19880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19881 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19882 Py_INCREF(obj);
19883 return Py_BuildValue((char *)"");
19884 }
19885 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj;
19887 wxWindow *arg1 = (wxWindow *) NULL ;
19888 wxChildFocusEvent *result;
19889 PyObject * obj0 = 0 ;
19890 char *kwnames[] = {
19891 (char *) "win", NULL
19892 };
19893
19894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19895 if (obj0) {
19896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19897 if (SWIG_arg_fail(1)) SWIG_fail;
19898 }
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19902
19903 wxPyEndAllowThreads(__tstate);
19904 if (PyErr_Occurred()) SWIG_fail;
19905 }
19906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19907 return resultobj;
19908 fail:
19909 return NULL;
19910 }
19911
19912
19913 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19914 PyObject *resultobj;
19915 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19916 wxWindow *result;
19917 PyObject * obj0 = 0 ;
19918 char *kwnames[] = {
19919 (char *) "self", NULL
19920 };
19921
19922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19924 if (SWIG_arg_fail(1)) SWIG_fail;
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19928
19929 wxPyEndAllowThreads(__tstate);
19930 if (PyErr_Occurred()) SWIG_fail;
19931 }
19932 {
19933 resultobj = wxPyMake_wxObject(result, 0);
19934 }
19935 return resultobj;
19936 fail:
19937 return NULL;
19938 }
19939
19940
19941 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19942 PyObject *obj;
19943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19944 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19945 Py_INCREF(obj);
19946 return Py_BuildValue((char *)"");
19947 }
19948 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19949 PyObject *resultobj;
19950 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19951 bool arg2 = (bool) true ;
19952 int arg3 = (int) 0 ;
19953 wxActivateEvent *result;
19954 PyObject * obj0 = 0 ;
19955 PyObject * obj1 = 0 ;
19956 PyObject * obj2 = 0 ;
19957 char *kwnames[] = {
19958 (char *) "type",(char *) "active",(char *) "Id", NULL
19959 };
19960
19961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19962 if (obj0) {
19963 {
19964 arg1 = (wxEventType)(SWIG_As_int(obj0));
19965 if (SWIG_arg_fail(1)) SWIG_fail;
19966 }
19967 }
19968 if (obj1) {
19969 {
19970 arg2 = (bool)(SWIG_As_bool(obj1));
19971 if (SWIG_arg_fail(2)) SWIG_fail;
19972 }
19973 }
19974 if (obj2) {
19975 {
19976 arg3 = (int)(SWIG_As_int(obj2));
19977 if (SWIG_arg_fail(3)) SWIG_fail;
19978 }
19979 }
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19983
19984 wxPyEndAllowThreads(__tstate);
19985 if (PyErr_Occurred()) SWIG_fail;
19986 }
19987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19995 PyObject *resultobj;
19996 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19997 bool result;
19998 PyObject * obj0 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20009
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 {
20014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20015 }
20016 return resultobj;
20017 fail:
20018 return NULL;
20019 }
20020
20021
20022 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20023 PyObject *obj;
20024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20025 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20026 Py_INCREF(obj);
20027 return Py_BuildValue((char *)"");
20028 }
20029 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20030 PyObject *resultobj;
20031 int arg1 = (int) 0 ;
20032 wxInitDialogEvent *result;
20033 PyObject * obj0 = 0 ;
20034 char *kwnames[] = {
20035 (char *) "Id", NULL
20036 };
20037
20038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20039 if (obj0) {
20040 {
20041 arg1 = (int)(SWIG_As_int(obj0));
20042 if (SWIG_arg_fail(1)) SWIG_fail;
20043 }
20044 }
20045 {
20046 PyThreadState* __tstate = wxPyBeginAllowThreads();
20047 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20048
20049 wxPyEndAllowThreads(__tstate);
20050 if (PyErr_Occurred()) SWIG_fail;
20051 }
20052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20060 PyObject *obj;
20061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20062 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20063 Py_INCREF(obj);
20064 return Py_BuildValue((char *)"");
20065 }
20066 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20067 PyObject *resultobj;
20068 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20069 int arg2 = (int) 0 ;
20070 wxMenu *arg3 = (wxMenu *) NULL ;
20071 wxMenuEvent *result;
20072 PyObject * obj0 = 0 ;
20073 PyObject * obj1 = 0 ;
20074 PyObject * obj2 = 0 ;
20075 char *kwnames[] = {
20076 (char *) "type",(char *) "winid",(char *) "menu", NULL
20077 };
20078
20079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20080 if (obj0) {
20081 {
20082 arg1 = (wxEventType)(SWIG_As_int(obj0));
20083 if (SWIG_arg_fail(1)) SWIG_fail;
20084 }
20085 }
20086 if (obj1) {
20087 {
20088 arg2 = (int)(SWIG_As_int(obj1));
20089 if (SWIG_arg_fail(2)) SWIG_fail;
20090 }
20091 }
20092 if (obj2) {
20093 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20094 if (SWIG_arg_fail(3)) SWIG_fail;
20095 }
20096 {
20097 PyThreadState* __tstate = wxPyBeginAllowThreads();
20098 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20099
20100 wxPyEndAllowThreads(__tstate);
20101 if (PyErr_Occurred()) SWIG_fail;
20102 }
20103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20104 return resultobj;
20105 fail:
20106 return NULL;
20107 }
20108
20109
20110 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20111 PyObject *resultobj;
20112 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20113 int result;
20114 PyObject * obj0 = 0 ;
20115 char *kwnames[] = {
20116 (char *) "self", NULL
20117 };
20118
20119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20121 if (SWIG_arg_fail(1)) SWIG_fail;
20122 {
20123 PyThreadState* __tstate = wxPyBeginAllowThreads();
20124 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20125
20126 wxPyEndAllowThreads(__tstate);
20127 if (PyErr_Occurred()) SWIG_fail;
20128 }
20129 {
20130 resultobj = SWIG_From_int((int)(result));
20131 }
20132 return resultobj;
20133 fail:
20134 return NULL;
20135 }
20136
20137
20138 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20139 PyObject *resultobj;
20140 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20141 bool result;
20142 PyObject * obj0 = 0 ;
20143 char *kwnames[] = {
20144 (char *) "self", NULL
20145 };
20146
20147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20149 if (SWIG_arg_fail(1)) SWIG_fail;
20150 {
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20153
20154 wxPyEndAllowThreads(__tstate);
20155 if (PyErr_Occurred()) SWIG_fail;
20156 }
20157 {
20158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20159 }
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20169 wxMenu *result;
20170 PyObject * obj0 = 0 ;
20171 char *kwnames[] = {
20172 (char *) "self", NULL
20173 };
20174
20175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20177 if (SWIG_arg_fail(1)) SWIG_fail;
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20181
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 {
20186 resultobj = wxPyMake_wxObject(result, 0);
20187 }
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20195 PyObject *obj;
20196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20197 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20198 Py_INCREF(obj);
20199 return Py_BuildValue((char *)"");
20200 }
20201 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20202 PyObject *resultobj;
20203 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20204 int arg2 = (int) 0 ;
20205 wxCloseEvent *result;
20206 PyObject * obj0 = 0 ;
20207 PyObject * obj1 = 0 ;
20208 char *kwnames[] = {
20209 (char *) "type",(char *) "winid", NULL
20210 };
20211
20212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20213 if (obj0) {
20214 {
20215 arg1 = (wxEventType)(SWIG_As_int(obj0));
20216 if (SWIG_arg_fail(1)) SWIG_fail;
20217 }
20218 }
20219 if (obj1) {
20220 {
20221 arg2 = (int)(SWIG_As_int(obj1));
20222 if (SWIG_arg_fail(2)) SWIG_fail;
20223 }
20224 }
20225 {
20226 PyThreadState* __tstate = wxPyBeginAllowThreads();
20227 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20242 bool arg2 ;
20243 PyObject * obj0 = 0 ;
20244 PyObject * obj1 = 0 ;
20245 char *kwnames[] = {
20246 (char *) "self",(char *) "logOff", NULL
20247 };
20248
20249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20251 if (SWIG_arg_fail(1)) SWIG_fail;
20252 {
20253 arg2 = (bool)(SWIG_As_bool(obj1));
20254 if (SWIG_arg_fail(2)) SWIG_fail;
20255 }
20256 {
20257 PyThreadState* __tstate = wxPyBeginAllowThreads();
20258 (arg1)->SetLoggingOff(arg2);
20259
20260 wxPyEndAllowThreads(__tstate);
20261 if (PyErr_Occurred()) SWIG_fail;
20262 }
20263 Py_INCREF(Py_None); resultobj = Py_None;
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20271 PyObject *resultobj;
20272 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20273 bool result;
20274 PyObject * obj0 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 {
20290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20291 }
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20301 bool arg2 = (bool) true ;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 char *kwnames[] = {
20305 (char *) "self",(char *) "veto", NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20310 if (SWIG_arg_fail(1)) SWIG_fail;
20311 if (obj1) {
20312 {
20313 arg2 = (bool)(SWIG_As_bool(obj1));
20314 if (SWIG_arg_fail(2)) SWIG_fail;
20315 }
20316 }
20317 {
20318 PyThreadState* __tstate = wxPyBeginAllowThreads();
20319 (arg1)->Veto(arg2);
20320
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 Py_INCREF(Py_None); resultobj = Py_None;
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20332 PyObject *resultobj;
20333 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20334 bool arg2 ;
20335 PyObject * obj0 = 0 ;
20336 PyObject * obj1 = 0 ;
20337 char *kwnames[] = {
20338 (char *) "self",(char *) "canVeto", NULL
20339 };
20340
20341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20343 if (SWIG_arg_fail(1)) SWIG_fail;
20344 {
20345 arg2 = (bool)(SWIG_As_bool(obj1));
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 (arg1)->SetCanVeto(arg2);
20351
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 Py_INCREF(Py_None); resultobj = Py_None;
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20363 PyObject *resultobj;
20364 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20365 bool result;
20366 PyObject * obj0 = 0 ;
20367 char *kwnames[] = {
20368 (char *) "self", NULL
20369 };
20370
20371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20373 if (SWIG_arg_fail(1)) SWIG_fail;
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20377
20378 wxPyEndAllowThreads(__tstate);
20379 if (PyErr_Occurred()) SWIG_fail;
20380 }
20381 {
20382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20383 }
20384 return resultobj;
20385 fail:
20386 return NULL;
20387 }
20388
20389
20390 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20391 PyObject *resultobj;
20392 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20393 bool result;
20394 PyObject * obj0 = 0 ;
20395 char *kwnames[] = {
20396 (char *) "self", NULL
20397 };
20398
20399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20401 if (SWIG_arg_fail(1)) SWIG_fail;
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20405
20406 wxPyEndAllowThreads(__tstate);
20407 if (PyErr_Occurred()) SWIG_fail;
20408 }
20409 {
20410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20411 }
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20419 PyObject *obj;
20420 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20421 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20422 Py_INCREF(obj);
20423 return Py_BuildValue((char *)"");
20424 }
20425 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj;
20427 int arg1 = (int) 0 ;
20428 bool arg2 = (bool) false ;
20429 wxShowEvent *result;
20430 PyObject * obj0 = 0 ;
20431 PyObject * obj1 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "winid",(char *) "show", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20437 if (obj0) {
20438 {
20439 arg1 = (int)(SWIG_As_int(obj0));
20440 if (SWIG_arg_fail(1)) SWIG_fail;
20441 }
20442 }
20443 if (obj1) {
20444 {
20445 arg2 = (bool)(SWIG_As_bool(obj1));
20446 if (SWIG_arg_fail(2)) SWIG_fail;
20447 }
20448 }
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20452
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20466 bool arg2 ;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 char *kwnames[] = {
20470 (char *) "self",(char *) "show", NULL
20471 };
20472
20473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20475 if (SWIG_arg_fail(1)) SWIG_fail;
20476 {
20477 arg2 = (bool)(SWIG_As_bool(obj1));
20478 if (SWIG_arg_fail(2)) SWIG_fail;
20479 }
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 (arg1)->SetShow(arg2);
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 Py_INCREF(Py_None); resultobj = Py_None;
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj;
20496 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20497 bool result;
20498 PyObject * obj0 = 0 ;
20499 char *kwnames[] = {
20500 (char *) "self", NULL
20501 };
20502
20503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20505 if (SWIG_arg_fail(1)) SWIG_fail;
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20509
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 {
20514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20515 }
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20523 PyObject *obj;
20524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20525 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20526 Py_INCREF(obj);
20527 return Py_BuildValue((char *)"");
20528 }
20529 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj;
20531 int arg1 = (int) 0 ;
20532 bool arg2 = (bool) true ;
20533 wxIconizeEvent *result;
20534 PyObject * obj0 = 0 ;
20535 PyObject * obj1 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "id",(char *) "iconized", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20541 if (obj0) {
20542 {
20543 arg1 = (int)(SWIG_As_int(obj0));
20544 if (SWIG_arg_fail(1)) SWIG_fail;
20545 }
20546 }
20547 if (obj1) {
20548 {
20549 arg2 = (bool)(SWIG_As_bool(obj1));
20550 if (SWIG_arg_fail(2)) SWIG_fail;
20551 }
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20556
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj;
20569 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20570 bool result;
20571 PyObject * obj0 = 0 ;
20572 char *kwnames[] = {
20573 (char *) "self", NULL
20574 };
20575
20576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (bool)(arg1)->Iconized();
20582
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20596 PyObject *obj;
20597 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20598 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20599 Py_INCREF(obj);
20600 return Py_BuildValue((char *)"");
20601 }
20602 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20603 PyObject *resultobj;
20604 int arg1 = (int) 0 ;
20605 wxMaximizeEvent *result;
20606 PyObject * obj0 = 0 ;
20607 char *kwnames[] = {
20608 (char *) "id", NULL
20609 };
20610
20611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20612 if (obj0) {
20613 {
20614 arg1 = (int)(SWIG_As_int(obj0));
20615 if (SWIG_arg_fail(1)) SWIG_fail;
20616 }
20617 }
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20621
20622 wxPyEndAllowThreads(__tstate);
20623 if (PyErr_Occurred()) SWIG_fail;
20624 }
20625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20633 PyObject *obj;
20634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20635 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20636 Py_INCREF(obj);
20637 return Py_BuildValue((char *)"");
20638 }
20639 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj;
20641 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20642 wxPoint result;
20643 PyObject * obj0 = 0 ;
20644 char *kwnames[] = {
20645 (char *) "self", NULL
20646 };
20647
20648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20650 if (SWIG_arg_fail(1)) SWIG_fail;
20651 {
20652 PyThreadState* __tstate = wxPyBeginAllowThreads();
20653 result = (arg1)->GetPosition();
20654
20655 wxPyEndAllowThreads(__tstate);
20656 if (PyErr_Occurred()) SWIG_fail;
20657 }
20658 {
20659 wxPoint * resultptr;
20660 resultptr = new wxPoint((wxPoint &)(result));
20661 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20662 }
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj;
20671 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20672 int result;
20673 PyObject * obj0 = 0 ;
20674 char *kwnames[] = {
20675 (char *) "self", NULL
20676 };
20677
20678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20680 if (SWIG_arg_fail(1)) SWIG_fail;
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (int)(arg1)->GetNumberOfFiles();
20684
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 {
20689 resultobj = SWIG_From_int((int)(result));
20690 }
20691 return resultobj;
20692 fail:
20693 return NULL;
20694 }
20695
20696
20697 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20698 PyObject *resultobj;
20699 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20700 PyObject *result;
20701 PyObject * obj0 = 0 ;
20702 char *kwnames[] = {
20703 (char *) "self", NULL
20704 };
20705
20706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20708 if (SWIG_arg_fail(1)) SWIG_fail;
20709 {
20710 PyThreadState* __tstate = wxPyBeginAllowThreads();
20711 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20712
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 resultobj = result;
20717 return resultobj;
20718 fail:
20719 return NULL;
20720 }
20721
20722
20723 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20724 PyObject *obj;
20725 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20726 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20727 Py_INCREF(obj);
20728 return Py_BuildValue((char *)"");
20729 }
20730 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20731 PyObject *resultobj;
20732 int arg1 = (int) 0 ;
20733 wxUpdateUIEvent *result;
20734 PyObject * obj0 = 0 ;
20735 char *kwnames[] = {
20736 (char *) "commandId", NULL
20737 };
20738
20739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20740 if (obj0) {
20741 {
20742 arg1 = (int)(SWIG_As_int(obj0));
20743 if (SWIG_arg_fail(1)) SWIG_fail;
20744 }
20745 }
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20749
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20754 return resultobj;
20755 fail:
20756 return NULL;
20757 }
20758
20759
20760 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20761 PyObject *resultobj;
20762 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20763 bool result;
20764 PyObject * obj0 = 0 ;
20765 char *kwnames[] = {
20766 (char *) "self", NULL
20767 };
20768
20769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20771 if (SWIG_arg_fail(1)) SWIG_fail;
20772 {
20773 PyThreadState* __tstate = wxPyBeginAllowThreads();
20774 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20775
20776 wxPyEndAllowThreads(__tstate);
20777 if (PyErr_Occurred()) SWIG_fail;
20778 }
20779 {
20780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20781 }
20782 return resultobj;
20783 fail:
20784 return NULL;
20785 }
20786
20787
20788 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20789 PyObject *resultobj;
20790 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20791 bool result;
20792 PyObject * obj0 = 0 ;
20793 char *kwnames[] = {
20794 (char *) "self", NULL
20795 };
20796
20797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20799 if (SWIG_arg_fail(1)) SWIG_fail;
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20803
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 {
20808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj;
20818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20819 wxString result;
20820 PyObject * obj0 = 0 ;
20821 char *kwnames[] = {
20822 (char *) "self", NULL
20823 };
20824
20825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20827 if (SWIG_arg_fail(1)) SWIG_fail;
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20831
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 {
20836 #if wxUSE_UNICODE
20837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20838 #else
20839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20840 #endif
20841 }
20842 return resultobj;
20843 fail:
20844 return NULL;
20845 }
20846
20847
20848 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj;
20850 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20851 bool result;
20852 PyObject * obj0 = 0 ;
20853 char *kwnames[] = {
20854 (char *) "self", NULL
20855 };
20856
20857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20859 if (SWIG_arg_fail(1)) SWIG_fail;
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20863
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 {
20868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20869 }
20870 return resultobj;
20871 fail:
20872 return NULL;
20873 }
20874
20875
20876 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20877 PyObject *resultobj;
20878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20879 bool result;
20880 PyObject * obj0 = 0 ;
20881 char *kwnames[] = {
20882 (char *) "self", NULL
20883 };
20884
20885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20887 if (SWIG_arg_fail(1)) SWIG_fail;
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20891
20892 wxPyEndAllowThreads(__tstate);
20893 if (PyErr_Occurred()) SWIG_fail;
20894 }
20895 {
20896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20897 }
20898 return resultobj;
20899 fail:
20900 return NULL;
20901 }
20902
20903
20904 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20905 PyObject *resultobj;
20906 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20907 bool result;
20908 PyObject * obj0 = 0 ;
20909 char *kwnames[] = {
20910 (char *) "self", NULL
20911 };
20912
20913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20915 if (SWIG_arg_fail(1)) SWIG_fail;
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20919
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 {
20924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20925 }
20926 return resultobj;
20927 fail:
20928 return NULL;
20929 }
20930
20931
20932 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20933 PyObject *resultobj;
20934 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20935 bool arg2 ;
20936 PyObject * obj0 = 0 ;
20937 PyObject * obj1 = 0 ;
20938 char *kwnames[] = {
20939 (char *) "self",(char *) "check", NULL
20940 };
20941
20942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20944 if (SWIG_arg_fail(1)) SWIG_fail;
20945 {
20946 arg2 = (bool)(SWIG_As_bool(obj1));
20947 if (SWIG_arg_fail(2)) SWIG_fail;
20948 }
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 (arg1)->Check(arg2);
20952
20953 wxPyEndAllowThreads(__tstate);
20954 if (PyErr_Occurred()) SWIG_fail;
20955 }
20956 Py_INCREF(Py_None); resultobj = Py_None;
20957 return resultobj;
20958 fail:
20959 return NULL;
20960 }
20961
20962
20963 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20964 PyObject *resultobj;
20965 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20966 bool arg2 ;
20967 PyObject * obj0 = 0 ;
20968 PyObject * obj1 = 0 ;
20969 char *kwnames[] = {
20970 (char *) "self",(char *) "enable", NULL
20971 };
20972
20973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20975 if (SWIG_arg_fail(1)) SWIG_fail;
20976 {
20977 arg2 = (bool)(SWIG_As_bool(obj1));
20978 if (SWIG_arg_fail(2)) SWIG_fail;
20979 }
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 (arg1)->Enable(arg2);
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 Py_INCREF(Py_None); resultobj = Py_None;
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20997 wxString *arg2 = 0 ;
20998 bool temp2 = false ;
20999 PyObject * obj0 = 0 ;
21000 PyObject * obj1 = 0 ;
21001 char *kwnames[] = {
21002 (char *) "self",(char *) "text", NULL
21003 };
21004
21005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21007 if (SWIG_arg_fail(1)) SWIG_fail;
21008 {
21009 arg2 = wxString_in_helper(obj1);
21010 if (arg2 == NULL) SWIG_fail;
21011 temp2 = true;
21012 }
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 (arg1)->SetText((wxString const &)*arg2);
21016
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 Py_INCREF(Py_None); resultobj = Py_None;
21021 {
21022 if (temp2)
21023 delete arg2;
21024 }
21025 return resultobj;
21026 fail:
21027 {
21028 if (temp2)
21029 delete arg2;
21030 }
21031 return NULL;
21032 }
21033
21034
21035 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21036 PyObject *resultobj;
21037 long arg1 ;
21038 PyObject * obj0 = 0 ;
21039 char *kwnames[] = {
21040 (char *) "updateInterval", NULL
21041 };
21042
21043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21044 {
21045 arg1 = (long)(SWIG_As_long(obj0));
21046 if (SWIG_arg_fail(1)) SWIG_fail;
21047 }
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 wxUpdateUIEvent::SetUpdateInterval(arg1);
21051
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 Py_INCREF(Py_None); resultobj = Py_None;
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21063 PyObject *resultobj;
21064 long result;
21065 char *kwnames[] = {
21066 NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21070 {
21071 PyThreadState* __tstate = wxPyBeginAllowThreads();
21072 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21073
21074 wxPyEndAllowThreads(__tstate);
21075 if (PyErr_Occurred()) SWIG_fail;
21076 }
21077 {
21078 resultobj = SWIG_From_long((long)(result));
21079 }
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj;
21088 wxWindow *arg1 = (wxWindow *) 0 ;
21089 bool result;
21090 PyObject * obj0 = 0 ;
21091 char *kwnames[] = {
21092 (char *) "win", NULL
21093 };
21094
21095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21097 if (SWIG_arg_fail(1)) SWIG_fail;
21098 {
21099 PyThreadState* __tstate = wxPyBeginAllowThreads();
21100 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21101
21102 wxPyEndAllowThreads(__tstate);
21103 if (PyErr_Occurred()) SWIG_fail;
21104 }
21105 {
21106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21107 }
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21115 PyObject *resultobj;
21116 char *kwnames[] = {
21117 NULL
21118 };
21119
21120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21121 {
21122 PyThreadState* __tstate = wxPyBeginAllowThreads();
21123 wxUpdateUIEvent::ResetUpdateTime();
21124
21125 wxPyEndAllowThreads(__tstate);
21126 if (PyErr_Occurred()) SWIG_fail;
21127 }
21128 Py_INCREF(Py_None); resultobj = Py_None;
21129 return resultobj;
21130 fail:
21131 return NULL;
21132 }
21133
21134
21135 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21136 PyObject *resultobj;
21137 wxUpdateUIMode arg1 ;
21138 PyObject * obj0 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "mode", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21144 {
21145 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21146 if (SWIG_arg_fail(1)) SWIG_fail;
21147 }
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21151
21152 wxPyEndAllowThreads(__tstate);
21153 if (PyErr_Occurred()) SWIG_fail;
21154 }
21155 Py_INCREF(Py_None); resultobj = Py_None;
21156 return resultobj;
21157 fail:
21158 return NULL;
21159 }
21160
21161
21162 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21163 PyObject *resultobj;
21164 wxUpdateUIMode result;
21165 char *kwnames[] = {
21166 NULL
21167 };
21168
21169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21173
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 resultobj = SWIG_From_int((result));
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21185 PyObject *obj;
21186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21187 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21188 Py_INCREF(obj);
21189 return Py_BuildValue((char *)"");
21190 }
21191 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21192 PyObject *resultobj;
21193 wxSysColourChangedEvent *result;
21194 char *kwnames[] = {
21195 NULL
21196 };
21197
21198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21199 {
21200 PyThreadState* __tstate = wxPyBeginAllowThreads();
21201 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21202
21203 wxPyEndAllowThreads(__tstate);
21204 if (PyErr_Occurred()) SWIG_fail;
21205 }
21206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21207 return resultobj;
21208 fail:
21209 return NULL;
21210 }
21211
21212
21213 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21214 PyObject *obj;
21215 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21216 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21217 Py_INCREF(obj);
21218 return Py_BuildValue((char *)"");
21219 }
21220 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21221 PyObject *resultobj;
21222 int arg1 = (int) 0 ;
21223 wxWindow *arg2 = (wxWindow *) NULL ;
21224 wxMouseCaptureChangedEvent *result;
21225 PyObject * obj0 = 0 ;
21226 PyObject * obj1 = 0 ;
21227 char *kwnames[] = {
21228 (char *) "winid",(char *) "gainedCapture", NULL
21229 };
21230
21231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21232 if (obj0) {
21233 {
21234 arg1 = (int)(SWIG_As_int(obj0));
21235 if (SWIG_arg_fail(1)) SWIG_fail;
21236 }
21237 }
21238 if (obj1) {
21239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21240 if (SWIG_arg_fail(2)) SWIG_fail;
21241 }
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21245
21246 wxPyEndAllowThreads(__tstate);
21247 if (PyErr_Occurred()) SWIG_fail;
21248 }
21249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21250 return resultobj;
21251 fail:
21252 return NULL;
21253 }
21254
21255
21256 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21257 PyObject *resultobj;
21258 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21259 wxWindow *result;
21260 PyObject * obj0 = 0 ;
21261 char *kwnames[] = {
21262 (char *) "self", NULL
21263 };
21264
21265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21267 if (SWIG_arg_fail(1)) SWIG_fail;
21268 {
21269 PyThreadState* __tstate = wxPyBeginAllowThreads();
21270 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21271
21272 wxPyEndAllowThreads(__tstate);
21273 if (PyErr_Occurred()) SWIG_fail;
21274 }
21275 {
21276 resultobj = wxPyMake_wxObject(result, 0);
21277 }
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21285 PyObject *obj;
21286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21287 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21288 Py_INCREF(obj);
21289 return Py_BuildValue((char *)"");
21290 }
21291 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21292 PyObject *resultobj;
21293 wxDisplayChangedEvent *result;
21294 char *kwnames[] = {
21295 NULL
21296 };
21297
21298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21314 PyObject *obj;
21315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21316 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21317 Py_INCREF(obj);
21318 return Py_BuildValue((char *)"");
21319 }
21320 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21321 PyObject *resultobj;
21322 int arg1 = (int) 0 ;
21323 wxPaletteChangedEvent *result;
21324 PyObject * obj0 = 0 ;
21325 char *kwnames[] = {
21326 (char *) "id", NULL
21327 };
21328
21329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21330 if (obj0) {
21331 {
21332 arg1 = (int)(SWIG_As_int(obj0));
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 }
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21351 PyObject *resultobj;
21352 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21353 wxWindow *arg2 = (wxWindow *) 0 ;
21354 PyObject * obj0 = 0 ;
21355 PyObject * obj1 = 0 ;
21356 char *kwnames[] = {
21357 (char *) "self",(char *) "win", NULL
21358 };
21359
21360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21362 if (SWIG_arg_fail(1)) SWIG_fail;
21363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21364 if (SWIG_arg_fail(2)) SWIG_fail;
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 (arg1)->SetChangedWindow(arg2);
21368
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 Py_INCREF(Py_None); resultobj = Py_None;
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21380 PyObject *resultobj;
21381 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21382 wxWindow *result;
21383 PyObject * obj0 = 0 ;
21384 char *kwnames[] = {
21385 (char *) "self", NULL
21386 };
21387
21388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21390 if (SWIG_arg_fail(1)) SWIG_fail;
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (wxWindow *)(arg1)->GetChangedWindow();
21394
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = wxPyMake_wxObject(result, 0);
21400 }
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21408 PyObject *obj;
21409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21410 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21411 Py_INCREF(obj);
21412 return Py_BuildValue((char *)"");
21413 }
21414 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21415 PyObject *resultobj;
21416 int arg1 = (int) 0 ;
21417 wxQueryNewPaletteEvent *result;
21418 PyObject * obj0 = 0 ;
21419 char *kwnames[] = {
21420 (char *) "winid", NULL
21421 };
21422
21423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21424 if (obj0) {
21425 {
21426 arg1 = (int)(SWIG_As_int(obj0));
21427 if (SWIG_arg_fail(1)) SWIG_fail;
21428 }
21429 }
21430 {
21431 PyThreadState* __tstate = wxPyBeginAllowThreads();
21432 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21433
21434 wxPyEndAllowThreads(__tstate);
21435 if (PyErr_Occurred()) SWIG_fail;
21436 }
21437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21438 return resultobj;
21439 fail:
21440 return NULL;
21441 }
21442
21443
21444 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21445 PyObject *resultobj;
21446 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21447 bool arg2 ;
21448 PyObject * obj0 = 0 ;
21449 PyObject * obj1 = 0 ;
21450 char *kwnames[] = {
21451 (char *) "self",(char *) "realized", NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21456 if (SWIG_arg_fail(1)) SWIG_fail;
21457 {
21458 arg2 = (bool)(SWIG_As_bool(obj1));
21459 if (SWIG_arg_fail(2)) SWIG_fail;
21460 }
21461 {
21462 PyThreadState* __tstate = wxPyBeginAllowThreads();
21463 (arg1)->SetPaletteRealized(arg2);
21464
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 Py_INCREF(Py_None); resultobj = Py_None;
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21476 PyObject *resultobj;
21477 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21478 bool result;
21479 PyObject * obj0 = 0 ;
21480 char *kwnames[] = {
21481 (char *) "self", NULL
21482 };
21483
21484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21486 if (SWIG_arg_fail(1)) SWIG_fail;
21487 {
21488 PyThreadState* __tstate = wxPyBeginAllowThreads();
21489 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21490
21491 wxPyEndAllowThreads(__tstate);
21492 if (PyErr_Occurred()) SWIG_fail;
21493 }
21494 {
21495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21496 }
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21504 PyObject *obj;
21505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21506 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21507 Py_INCREF(obj);
21508 return Py_BuildValue((char *)"");
21509 }
21510 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj;
21512 wxNavigationKeyEvent *result;
21513 char *kwnames[] = {
21514 NULL
21515 };
21516
21517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21521
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21533 PyObject *resultobj;
21534 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21535 bool result;
21536 PyObject * obj0 = 0 ;
21537 char *kwnames[] = {
21538 (char *) "self", NULL
21539 };
21540
21541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21543 if (SWIG_arg_fail(1)) SWIG_fail;
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21547
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 {
21552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21553 }
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj;
21562 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21563 bool arg2 ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 char *kwnames[] = {
21567 (char *) "self",(char *) "forward", NULL
21568 };
21569
21570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21572 if (SWIG_arg_fail(1)) SWIG_fail;
21573 {
21574 arg2 = (bool)(SWIG_As_bool(obj1));
21575 if (SWIG_arg_fail(2)) SWIG_fail;
21576 }
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 (arg1)->SetDirection(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 *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21592 PyObject *resultobj;
21593 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21594 bool result;
21595 PyObject * obj0 = 0 ;
21596 char *kwnames[] = {
21597 (char *) "self", NULL
21598 };
21599
21600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21602 if (SWIG_arg_fail(1)) SWIG_fail;
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21606
21607 wxPyEndAllowThreads(__tstate);
21608 if (PyErr_Occurred()) SWIG_fail;
21609 }
21610 {
21611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21612 }
21613 return resultobj;
21614 fail:
21615 return NULL;
21616 }
21617
21618
21619 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21622 bool arg2 ;
21623 PyObject * obj0 = 0 ;
21624 PyObject * obj1 = 0 ;
21625 char *kwnames[] = {
21626 (char *) "self",(char *) "ischange", NULL
21627 };
21628
21629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21631 if (SWIG_arg_fail(1)) SWIG_fail;
21632 {
21633 arg2 = (bool)(SWIG_As_bool(obj1));
21634 if (SWIG_arg_fail(2)) SWIG_fail;
21635 }
21636 {
21637 PyThreadState* __tstate = wxPyBeginAllowThreads();
21638 (arg1)->SetWindowChange(arg2);
21639
21640 wxPyEndAllowThreads(__tstate);
21641 if (PyErr_Occurred()) SWIG_fail;
21642 }
21643 Py_INCREF(Py_None); resultobj = Py_None;
21644 return resultobj;
21645 fail:
21646 return NULL;
21647 }
21648
21649
21650 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21651 PyObject *resultobj;
21652 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21653 bool result;
21654 PyObject * obj0 = 0 ;
21655 char *kwnames[] = {
21656 (char *) "self", NULL
21657 };
21658
21659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21661 if (SWIG_arg_fail(1)) SWIG_fail;
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21665
21666 wxPyEndAllowThreads(__tstate);
21667 if (PyErr_Occurred()) SWIG_fail;
21668 }
21669 {
21670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21671 }
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj;
21680 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21681 bool arg2 ;
21682 PyObject * obj0 = 0 ;
21683 PyObject * obj1 = 0 ;
21684 char *kwnames[] = {
21685 (char *) "self",(char *) "bIs", NULL
21686 };
21687
21688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21690 if (SWIG_arg_fail(1)) SWIG_fail;
21691 {
21692 arg2 = (bool)(SWIG_As_bool(obj1));
21693 if (SWIG_arg_fail(2)) SWIG_fail;
21694 }
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 (arg1)->SetFromTab(arg2);
21698
21699 wxPyEndAllowThreads(__tstate);
21700 if (PyErr_Occurred()) SWIG_fail;
21701 }
21702 Py_INCREF(Py_None); resultobj = Py_None;
21703 return resultobj;
21704 fail:
21705 return NULL;
21706 }
21707
21708
21709 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21710 PyObject *resultobj;
21711 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21712 long arg2 ;
21713 PyObject * obj0 = 0 ;
21714 PyObject * obj1 = 0 ;
21715 char *kwnames[] = {
21716 (char *) "self",(char *) "flags", NULL
21717 };
21718
21719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21721 if (SWIG_arg_fail(1)) SWIG_fail;
21722 {
21723 arg2 = (long)(SWIG_As_long(obj1));
21724 if (SWIG_arg_fail(2)) SWIG_fail;
21725 }
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 (arg1)->SetFlags(arg2);
21729
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 Py_INCREF(Py_None); resultobj = Py_None;
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21741 PyObject *resultobj;
21742 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21743 wxWindow *result;
21744 PyObject * obj0 = 0 ;
21745 char *kwnames[] = {
21746 (char *) "self", NULL
21747 };
21748
21749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21751 if (SWIG_arg_fail(1)) SWIG_fail;
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21755
21756 wxPyEndAllowThreads(__tstate);
21757 if (PyErr_Occurred()) SWIG_fail;
21758 }
21759 {
21760 resultobj = wxPyMake_wxObject(result, 0);
21761 }
21762 return resultobj;
21763 fail:
21764 return NULL;
21765 }
21766
21767
21768 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21769 PyObject *resultobj;
21770 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21771 wxWindow *arg2 = (wxWindow *) 0 ;
21772 PyObject * obj0 = 0 ;
21773 PyObject * obj1 = 0 ;
21774 char *kwnames[] = {
21775 (char *) "self",(char *) "win", NULL
21776 };
21777
21778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21780 if (SWIG_arg_fail(1)) SWIG_fail;
21781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21782 if (SWIG_arg_fail(2)) SWIG_fail;
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 (arg1)->SetCurrentFocus(arg2);
21786
21787 wxPyEndAllowThreads(__tstate);
21788 if (PyErr_Occurred()) SWIG_fail;
21789 }
21790 Py_INCREF(Py_None); resultobj = Py_None;
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21798 PyObject *obj;
21799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21800 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21801 Py_INCREF(obj);
21802 return Py_BuildValue((char *)"");
21803 }
21804 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21805 PyObject *resultobj;
21806 wxWindow *arg1 = (wxWindow *) NULL ;
21807 wxWindowCreateEvent *result;
21808 PyObject * obj0 = 0 ;
21809 char *kwnames[] = {
21810 (char *) "win", NULL
21811 };
21812
21813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21814 if (obj0) {
21815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21816 if (SWIG_arg_fail(1)) SWIG_fail;
21817 }
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21835 wxWindow *result;
21836 PyObject * obj0 = 0 ;
21837 char *kwnames[] = {
21838 (char *) "self", NULL
21839 };
21840
21841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21843 if (SWIG_arg_fail(1)) SWIG_fail;
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21847
21848 wxPyEndAllowThreads(__tstate);
21849 if (PyErr_Occurred()) SWIG_fail;
21850 }
21851 {
21852 resultobj = wxPyMake_wxObject(result, 0);
21853 }
21854 return resultobj;
21855 fail:
21856 return NULL;
21857 }
21858
21859
21860 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21861 PyObject *obj;
21862 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21863 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21864 Py_INCREF(obj);
21865 return Py_BuildValue((char *)"");
21866 }
21867 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21868 PyObject *resultobj;
21869 wxWindow *arg1 = (wxWindow *) NULL ;
21870 wxWindowDestroyEvent *result;
21871 PyObject * obj0 = 0 ;
21872 char *kwnames[] = {
21873 (char *) "win", NULL
21874 };
21875
21876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21877 if (obj0) {
21878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21879 if (SWIG_arg_fail(1)) SWIG_fail;
21880 }
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21884
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21889 return resultobj;
21890 fail:
21891 return NULL;
21892 }
21893
21894
21895 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21896 PyObject *resultobj;
21897 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21898 wxWindow *result;
21899 PyObject * obj0 = 0 ;
21900 char *kwnames[] = {
21901 (char *) "self", NULL
21902 };
21903
21904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21906 if (SWIG_arg_fail(1)) SWIG_fail;
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21910
21911 wxPyEndAllowThreads(__tstate);
21912 if (PyErr_Occurred()) SWIG_fail;
21913 }
21914 {
21915 resultobj = wxPyMake_wxObject(result, 0);
21916 }
21917 return resultobj;
21918 fail:
21919 return NULL;
21920 }
21921
21922
21923 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21924 PyObject *obj;
21925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21926 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21927 Py_INCREF(obj);
21928 return Py_BuildValue((char *)"");
21929 }
21930 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21931 PyObject *resultobj;
21932 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21933 int arg2 = (int) 0 ;
21934 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21935 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21936 wxContextMenuEvent *result;
21937 wxPoint temp3 ;
21938 PyObject * obj0 = 0 ;
21939 PyObject * obj1 = 0 ;
21940 PyObject * obj2 = 0 ;
21941 char *kwnames[] = {
21942 (char *) "type",(char *) "winid",(char *) "pt", NULL
21943 };
21944
21945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21946 if (obj0) {
21947 {
21948 arg1 = (wxEventType)(SWIG_As_int(obj0));
21949 if (SWIG_arg_fail(1)) SWIG_fail;
21950 }
21951 }
21952 if (obj1) {
21953 {
21954 arg2 = (int)(SWIG_As_int(obj1));
21955 if (SWIG_arg_fail(2)) SWIG_fail;
21956 }
21957 }
21958 if (obj2) {
21959 {
21960 arg3 = &temp3;
21961 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21962 }
21963 }
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21967
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21972 return resultobj;
21973 fail:
21974 return NULL;
21975 }
21976
21977
21978 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj;
21980 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21981 wxPoint *result;
21982 PyObject * obj0 = 0 ;
21983 char *kwnames[] = {
21984 (char *) "self", NULL
21985 };
21986
21987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21989 if (SWIG_arg_fail(1)) SWIG_fail;
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 {
21993 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21994 result = (wxPoint *) &_result_ref;
21995 }
21996
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22001 return resultobj;
22002 fail:
22003 return NULL;
22004 }
22005
22006
22007 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22008 PyObject *resultobj;
22009 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22010 wxPoint *arg2 = 0 ;
22011 wxPoint temp2 ;
22012 PyObject * obj0 = 0 ;
22013 PyObject * obj1 = 0 ;
22014 char *kwnames[] = {
22015 (char *) "self",(char *) "pos", NULL
22016 };
22017
22018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22020 if (SWIG_arg_fail(1)) SWIG_fail;
22021 {
22022 arg2 = &temp2;
22023 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22024 }
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 (arg1)->SetPosition((wxPoint const &)*arg2);
22028
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 Py_INCREF(Py_None); resultobj = Py_None;
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22040 PyObject *obj;
22041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22042 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22043 Py_INCREF(obj);
22044 return Py_BuildValue((char *)"");
22045 }
22046 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj;
22048 wxIdleEvent *result;
22049 char *kwnames[] = {
22050 NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (wxIdleEvent *)new wxIdleEvent();
22057
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22062 return resultobj;
22063 fail:
22064 return NULL;
22065 }
22066
22067
22068 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22069 PyObject *resultobj;
22070 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22071 bool arg2 = (bool) true ;
22072 PyObject * obj0 = 0 ;
22073 PyObject * obj1 = 0 ;
22074 char *kwnames[] = {
22075 (char *) "self",(char *) "needMore", NULL
22076 };
22077
22078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22080 if (SWIG_arg_fail(1)) SWIG_fail;
22081 if (obj1) {
22082 {
22083 arg2 = (bool)(SWIG_As_bool(obj1));
22084 if (SWIG_arg_fail(2)) SWIG_fail;
22085 }
22086 }
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 (arg1)->RequestMore(arg2);
22090
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 Py_INCREF(Py_None); resultobj = Py_None;
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22102 PyObject *resultobj;
22103 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22104 bool result;
22105 PyObject * obj0 = 0 ;
22106 char *kwnames[] = {
22107 (char *) "self", NULL
22108 };
22109
22110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 {
22114 PyThreadState* __tstate = wxPyBeginAllowThreads();
22115 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22116
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 {
22121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22122 }
22123 return resultobj;
22124 fail:
22125 return NULL;
22126 }
22127
22128
22129 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22130 PyObject *resultobj;
22131 wxIdleMode arg1 ;
22132 PyObject * obj0 = 0 ;
22133 char *kwnames[] = {
22134 (char *) "mode", NULL
22135 };
22136
22137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22138 {
22139 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22140 if (SWIG_arg_fail(1)) SWIG_fail;
22141 }
22142 {
22143 PyThreadState* __tstate = wxPyBeginAllowThreads();
22144 wxIdleEvent::SetMode((wxIdleMode )arg1);
22145
22146 wxPyEndAllowThreads(__tstate);
22147 if (PyErr_Occurred()) SWIG_fail;
22148 }
22149 Py_INCREF(Py_None); resultobj = Py_None;
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22157 PyObject *resultobj;
22158 wxIdleMode result;
22159 char *kwnames[] = {
22160 NULL
22161 };
22162
22163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (wxIdleMode)wxIdleEvent::GetMode();
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_From_int((result));
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj;
22180 wxWindow *arg1 = (wxWindow *) 0 ;
22181 bool result;
22182 PyObject * obj0 = 0 ;
22183 char *kwnames[] = {
22184 (char *) "win", NULL
22185 };
22186
22187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22189 if (SWIG_arg_fail(1)) SWIG_fail;
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 result = (bool)wxIdleEvent::CanSend(arg1);
22193
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 {
22198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22199 }
22200 return resultobj;
22201 fail:
22202 return NULL;
22203 }
22204
22205
22206 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22207 PyObject *obj;
22208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22209 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22210 Py_INCREF(obj);
22211 return Py_BuildValue((char *)"");
22212 }
22213 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22214 PyObject *resultobj;
22215 int arg1 = (int) 0 ;
22216 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22217 wxPyEvent *result;
22218 PyObject * obj0 = 0 ;
22219 PyObject * obj1 = 0 ;
22220 char *kwnames[] = {
22221 (char *) "winid",(char *) "commandType", NULL
22222 };
22223
22224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22225 if (obj0) {
22226 {
22227 arg1 = (int)(SWIG_As_int(obj0));
22228 if (SWIG_arg_fail(1)) SWIG_fail;
22229 }
22230 }
22231 if (obj1) {
22232 {
22233 arg2 = (wxEventType)(SWIG_As_int(obj1));
22234 if (SWIG_arg_fail(2)) SWIG_fail;
22235 }
22236 }
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22240
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj;
22253 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22254 PyObject * obj0 = 0 ;
22255 char *kwnames[] = {
22256 (char *) "self", NULL
22257 };
22258
22259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22261 if (SWIG_arg_fail(1)) SWIG_fail;
22262 {
22263 PyThreadState* __tstate = wxPyBeginAllowThreads();
22264 delete arg1;
22265
22266 wxPyEndAllowThreads(__tstate);
22267 if (PyErr_Occurred()) SWIG_fail;
22268 }
22269 Py_INCREF(Py_None); resultobj = Py_None;
22270 return resultobj;
22271 fail:
22272 return NULL;
22273 }
22274
22275
22276 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22277 PyObject *resultobj;
22278 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22279 PyObject *arg2 = (PyObject *) 0 ;
22280 PyObject * obj0 = 0 ;
22281 PyObject * obj1 = 0 ;
22282 char *kwnames[] = {
22283 (char *) "self",(char *) "self", NULL
22284 };
22285
22286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(1)) SWIG_fail;
22289 arg2 = obj1;
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 (arg1)->SetSelf(arg2);
22293
22294 wxPyEndAllowThreads(__tstate);
22295 if (PyErr_Occurred()) SWIG_fail;
22296 }
22297 Py_INCREF(Py_None); resultobj = Py_None;
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj;
22306 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22307 PyObject *result;
22308 PyObject * obj0 = 0 ;
22309 char *kwnames[] = {
22310 (char *) "self", NULL
22311 };
22312
22313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = (PyObject *)(arg1)->GetSelf();
22319
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 resultobj = result;
22324 return resultobj;
22325 fail:
22326 return NULL;
22327 }
22328
22329
22330 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22331 PyObject *obj;
22332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22333 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22334 Py_INCREF(obj);
22335 return Py_BuildValue((char *)"");
22336 }
22337 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22338 PyObject *resultobj;
22339 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22340 int arg2 = (int) 0 ;
22341 wxPyCommandEvent *result;
22342 PyObject * obj0 = 0 ;
22343 PyObject * obj1 = 0 ;
22344 char *kwnames[] = {
22345 (char *) "commandType",(char *) "id", NULL
22346 };
22347
22348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22349 if (obj0) {
22350 {
22351 arg1 = (wxEventType)(SWIG_As_int(obj0));
22352 if (SWIG_arg_fail(1)) SWIG_fail;
22353 }
22354 }
22355 if (obj1) {
22356 {
22357 arg2 = (int)(SWIG_As_int(obj1));
22358 if (SWIG_arg_fail(2)) SWIG_fail;
22359 }
22360 }
22361 {
22362 PyThreadState* __tstate = wxPyBeginAllowThreads();
22363 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22364
22365 wxPyEndAllowThreads(__tstate);
22366 if (PyErr_Occurred()) SWIG_fail;
22367 }
22368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22376 PyObject *resultobj;
22377 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22378 PyObject * obj0 = 0 ;
22379 char *kwnames[] = {
22380 (char *) "self", NULL
22381 };
22382
22383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(1)) SWIG_fail;
22386 {
22387 PyThreadState* __tstate = wxPyBeginAllowThreads();
22388 delete arg1;
22389
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 Py_INCREF(Py_None); resultobj = Py_None;
22394 return resultobj;
22395 fail:
22396 return NULL;
22397 }
22398
22399
22400 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22401 PyObject *resultobj;
22402 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22403 PyObject *arg2 = (PyObject *) 0 ;
22404 PyObject * obj0 = 0 ;
22405 PyObject * obj1 = 0 ;
22406 char *kwnames[] = {
22407 (char *) "self",(char *) "self", NULL
22408 };
22409
22410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22412 if (SWIG_arg_fail(1)) SWIG_fail;
22413 arg2 = obj1;
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 (arg1)->SetSelf(arg2);
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 Py_INCREF(Py_None); resultobj = Py_None;
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22431 PyObject *result;
22432 PyObject * obj0 = 0 ;
22433 char *kwnames[] = {
22434 (char *) "self", NULL
22435 };
22436
22437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22439 if (SWIG_arg_fail(1)) SWIG_fail;
22440 {
22441 PyThreadState* __tstate = wxPyBeginAllowThreads();
22442 result = (PyObject *)(arg1)->GetSelf();
22443
22444 wxPyEndAllowThreads(__tstate);
22445 if (PyErr_Occurred()) SWIG_fail;
22446 }
22447 resultobj = result;
22448 return resultobj;
22449 fail:
22450 return NULL;
22451 }
22452
22453
22454 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22455 PyObject *obj;
22456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22457 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22458 Py_INCREF(obj);
22459 return Py_BuildValue((char *)"");
22460 }
22461 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxWindow *arg1 = (wxWindow *) 0 ;
22464 wxDateTime *arg2 = 0 ;
22465 wxEventType arg3 ;
22466 wxDateEvent *result;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 PyObject * obj2 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "win",(char *) "dt",(char *) "type", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 {
22478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22479 if (SWIG_arg_fail(2)) SWIG_fail;
22480 if (arg2 == NULL) {
22481 SWIG_null_ref("wxDateTime");
22482 }
22483 if (SWIG_arg_fail(2)) SWIG_fail;
22484 }
22485 {
22486 arg3 = (wxEventType)(SWIG_As_int(obj2));
22487 if (SWIG_arg_fail(3)) SWIG_fail;
22488 }
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj;
22505 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22506 wxDateTime *result;
22507 PyObject * obj0 = 0 ;
22508 char *kwnames[] = {
22509 (char *) "self", NULL
22510 };
22511
22512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 {
22518 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22519 result = (wxDateTime *) &_result_ref;
22520 }
22521
22522 wxPyEndAllowThreads(__tstate);
22523 if (PyErr_Occurred()) SWIG_fail;
22524 }
22525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22526 return resultobj;
22527 fail:
22528 return NULL;
22529 }
22530
22531
22532 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22533 PyObject *resultobj;
22534 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22535 wxDateTime *arg2 = 0 ;
22536 PyObject * obj0 = 0 ;
22537 PyObject * obj1 = 0 ;
22538 char *kwnames[] = {
22539 (char *) "self",(char *) "date", NULL
22540 };
22541
22542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22544 if (SWIG_arg_fail(1)) SWIG_fail;
22545 {
22546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22547 if (SWIG_arg_fail(2)) SWIG_fail;
22548 if (arg2 == NULL) {
22549 SWIG_null_ref("wxDateTime");
22550 }
22551 if (SWIG_arg_fail(2)) SWIG_fail;
22552 }
22553 {
22554 PyThreadState* __tstate = wxPyBeginAllowThreads();
22555 (arg1)->SetDate((wxDateTime const &)*arg2);
22556
22557 wxPyEndAllowThreads(__tstate);
22558 if (PyErr_Occurred()) SWIG_fail;
22559 }
22560 Py_INCREF(Py_None); resultobj = Py_None;
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22568 PyObject *obj;
22569 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22570 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22571 Py_INCREF(obj);
22572 return Py_BuildValue((char *)"");
22573 }
22574 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22575 PyObject *resultobj;
22576 wxPyApp *result;
22577 char *kwnames[] = {
22578 NULL
22579 };
22580
22581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22582 {
22583 PyThreadState* __tstate = wxPyBeginAllowThreads();
22584 result = (wxPyApp *)new_wxPyApp();
22585
22586 wxPyEndAllowThreads(__tstate);
22587 if (PyErr_Occurred()) SWIG_fail;
22588 }
22589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22590 return resultobj;
22591 fail:
22592 return NULL;
22593 }
22594
22595
22596 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22597 PyObject *resultobj;
22598 wxPyApp *arg1 = (wxPyApp *) 0 ;
22599 PyObject * obj0 = 0 ;
22600 char *kwnames[] = {
22601 (char *) "self", NULL
22602 };
22603
22604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22606 if (SWIG_arg_fail(1)) SWIG_fail;
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 delete arg1;
22610
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 Py_INCREF(Py_None); resultobj = Py_None;
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj;
22623 wxPyApp *arg1 = (wxPyApp *) 0 ;
22624 PyObject *arg2 = (PyObject *) 0 ;
22625 PyObject *arg3 = (PyObject *) 0 ;
22626 PyObject * obj0 = 0 ;
22627 PyObject * obj1 = 0 ;
22628 PyObject * obj2 = 0 ;
22629 char *kwnames[] = {
22630 (char *) "self",(char *) "self",(char *) "_class", NULL
22631 };
22632
22633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22635 if (SWIG_arg_fail(1)) SWIG_fail;
22636 arg2 = obj1;
22637 arg3 = obj2;
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 (arg1)->_setCallbackInfo(arg2,arg3);
22641
22642 wxPyEndAllowThreads(__tstate);
22643 if (PyErr_Occurred()) SWIG_fail;
22644 }
22645 Py_INCREF(Py_None); resultobj = Py_None;
22646 return resultobj;
22647 fail:
22648 return NULL;
22649 }
22650
22651
22652 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22653 PyObject *resultobj;
22654 wxPyApp *arg1 = (wxPyApp *) 0 ;
22655 wxString result;
22656 PyObject * obj0 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 result = ((wxPyApp const *)arg1)->GetAppName();
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 {
22672 #if wxUSE_UNICODE
22673 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22674 #else
22675 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22676 #endif
22677 }
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22685 PyObject *resultobj;
22686 wxPyApp *arg1 = (wxPyApp *) 0 ;
22687 wxString *arg2 = 0 ;
22688 bool temp2 = false ;
22689 PyObject * obj0 = 0 ;
22690 PyObject * obj1 = 0 ;
22691 char *kwnames[] = {
22692 (char *) "self",(char *) "name", NULL
22693 };
22694
22695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22697 if (SWIG_arg_fail(1)) SWIG_fail;
22698 {
22699 arg2 = wxString_in_helper(obj1);
22700 if (arg2 == NULL) SWIG_fail;
22701 temp2 = true;
22702 }
22703 {
22704 PyThreadState* __tstate = wxPyBeginAllowThreads();
22705 (arg1)->SetAppName((wxString const &)*arg2);
22706
22707 wxPyEndAllowThreads(__tstate);
22708 if (PyErr_Occurred()) SWIG_fail;
22709 }
22710 Py_INCREF(Py_None); resultobj = Py_None;
22711 {
22712 if (temp2)
22713 delete arg2;
22714 }
22715 return resultobj;
22716 fail:
22717 {
22718 if (temp2)
22719 delete arg2;
22720 }
22721 return NULL;
22722 }
22723
22724
22725 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22726 PyObject *resultobj;
22727 wxPyApp *arg1 = (wxPyApp *) 0 ;
22728 wxString result;
22729 PyObject * obj0 = 0 ;
22730 char *kwnames[] = {
22731 (char *) "self", NULL
22732 };
22733
22734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(1)) SWIG_fail;
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = ((wxPyApp const *)arg1)->GetClassName();
22740
22741 wxPyEndAllowThreads(__tstate);
22742 if (PyErr_Occurred()) SWIG_fail;
22743 }
22744 {
22745 #if wxUSE_UNICODE
22746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22747 #else
22748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22749 #endif
22750 }
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22758 PyObject *resultobj;
22759 wxPyApp *arg1 = (wxPyApp *) 0 ;
22760 wxString *arg2 = 0 ;
22761 bool temp2 = false ;
22762 PyObject * obj0 = 0 ;
22763 PyObject * obj1 = 0 ;
22764 char *kwnames[] = {
22765 (char *) "self",(char *) "name", NULL
22766 };
22767
22768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(1)) SWIG_fail;
22771 {
22772 arg2 = wxString_in_helper(obj1);
22773 if (arg2 == NULL) SWIG_fail;
22774 temp2 = true;
22775 }
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 (arg1)->SetClassName((wxString const &)*arg2);
22779
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 Py_INCREF(Py_None); resultobj = Py_None;
22784 {
22785 if (temp2)
22786 delete arg2;
22787 }
22788 return resultobj;
22789 fail:
22790 {
22791 if (temp2)
22792 delete arg2;
22793 }
22794 return NULL;
22795 }
22796
22797
22798 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj;
22800 wxPyApp *arg1 = (wxPyApp *) 0 ;
22801 wxString *result;
22802 PyObject * obj0 = 0 ;
22803 char *kwnames[] = {
22804 (char *) "self", NULL
22805 };
22806
22807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22809 if (SWIG_arg_fail(1)) SWIG_fail;
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 {
22813 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22814 result = (wxString *) &_result_ref;
22815 }
22816
22817 wxPyEndAllowThreads(__tstate);
22818 if (PyErr_Occurred()) SWIG_fail;
22819 }
22820 {
22821 #if wxUSE_UNICODE
22822 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22823 #else
22824 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22825 #endif
22826 }
22827 return resultobj;
22828 fail:
22829 return NULL;
22830 }
22831
22832
22833 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22834 PyObject *resultobj;
22835 wxPyApp *arg1 = (wxPyApp *) 0 ;
22836 wxString *arg2 = 0 ;
22837 bool temp2 = false ;
22838 PyObject * obj0 = 0 ;
22839 PyObject * obj1 = 0 ;
22840 char *kwnames[] = {
22841 (char *) "self",(char *) "name", NULL
22842 };
22843
22844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22846 if (SWIG_arg_fail(1)) SWIG_fail;
22847 {
22848 arg2 = wxString_in_helper(obj1);
22849 if (arg2 == NULL) SWIG_fail;
22850 temp2 = true;
22851 }
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 (arg1)->SetVendorName((wxString const &)*arg2);
22855
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 Py_INCREF(Py_None); resultobj = Py_None;
22860 {
22861 if (temp2)
22862 delete arg2;
22863 }
22864 return resultobj;
22865 fail:
22866 {
22867 if (temp2)
22868 delete arg2;
22869 }
22870 return NULL;
22871 }
22872
22873
22874 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22875 PyObject *resultobj;
22876 wxPyApp *arg1 = (wxPyApp *) 0 ;
22877 wxAppTraits *result;
22878 PyObject * obj0 = 0 ;
22879 char *kwnames[] = {
22880 (char *) "self", NULL
22881 };
22882
22883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22885 if (SWIG_arg_fail(1)) SWIG_fail;
22886 {
22887 PyThreadState* __tstate = wxPyBeginAllowThreads();
22888 result = (wxAppTraits *)(arg1)->GetTraits();
22889
22890 wxPyEndAllowThreads(__tstate);
22891 if (PyErr_Occurred()) SWIG_fail;
22892 }
22893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22901 PyObject *resultobj;
22902 wxPyApp *arg1 = (wxPyApp *) 0 ;
22903 PyObject * obj0 = 0 ;
22904 char *kwnames[] = {
22905 (char *) "self", NULL
22906 };
22907
22908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22910 if (SWIG_arg_fail(1)) SWIG_fail;
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 (arg1)->ProcessPendingEvents();
22914
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 Py_INCREF(Py_None); resultobj = Py_None;
22919 return resultobj;
22920 fail:
22921 return NULL;
22922 }
22923
22924
22925 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22926 PyObject *resultobj;
22927 wxPyApp *arg1 = (wxPyApp *) 0 ;
22928 bool arg2 = (bool) false ;
22929 bool result;
22930 PyObject * obj0 = 0 ;
22931 PyObject * obj1 = 0 ;
22932 char *kwnames[] = {
22933 (char *) "self",(char *) "onlyIfNeeded", NULL
22934 };
22935
22936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22938 if (SWIG_arg_fail(1)) SWIG_fail;
22939 if (obj1) {
22940 {
22941 arg2 = (bool)(SWIG_As_bool(obj1));
22942 if (SWIG_arg_fail(2)) SWIG_fail;
22943 }
22944 }
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = (bool)(arg1)->Yield(arg2);
22948
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 {
22953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22954 }
22955 return resultobj;
22956 fail:
22957 return NULL;
22958 }
22959
22960
22961 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22962 PyObject *resultobj;
22963 wxPyApp *arg1 = (wxPyApp *) 0 ;
22964 PyObject * obj0 = 0 ;
22965 char *kwnames[] = {
22966 (char *) "self", NULL
22967 };
22968
22969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22971 if (SWIG_arg_fail(1)) SWIG_fail;
22972 {
22973 PyThreadState* __tstate = wxPyBeginAllowThreads();
22974 (arg1)->WakeUpIdle();
22975
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 Py_INCREF(Py_None); resultobj = Py_None;
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22987 PyObject *resultobj;
22988 bool result;
22989 char *kwnames[] = {
22990 NULL
22991 };
22992
22993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = (bool)wxPyApp::IsMainLoopRunning();
22997
22998 wxPyEndAllowThreads(__tstate);
22999 if (PyErr_Occurred()) SWIG_fail;
23000 }
23001 {
23002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23003 }
23004 return resultobj;
23005 fail:
23006 return NULL;
23007 }
23008
23009
23010 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23011 PyObject *resultobj;
23012 wxPyApp *arg1 = (wxPyApp *) 0 ;
23013 int result;
23014 PyObject * obj0 = 0 ;
23015 char *kwnames[] = {
23016 (char *) "self", NULL
23017 };
23018
23019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23021 if (SWIG_arg_fail(1)) SWIG_fail;
23022 {
23023 PyThreadState* __tstate = wxPyBeginAllowThreads();
23024 result = (int)(arg1)->MainLoop();
23025
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 {
23030 resultobj = SWIG_From_int((int)(result));
23031 }
23032 return resultobj;
23033 fail:
23034 return NULL;
23035 }
23036
23037
23038 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23039 PyObject *resultobj;
23040 wxPyApp *arg1 = (wxPyApp *) 0 ;
23041 PyObject * obj0 = 0 ;
23042 char *kwnames[] = {
23043 (char *) "self", NULL
23044 };
23045
23046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23048 if (SWIG_arg_fail(1)) SWIG_fail;
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 (arg1)->Exit();
23052
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 Py_INCREF(Py_None); resultobj = Py_None;
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23064 PyObject *resultobj;
23065 wxPyApp *arg1 = (wxPyApp *) 0 ;
23066 PyObject * obj0 = 0 ;
23067 char *kwnames[] = {
23068 (char *) "self", NULL
23069 };
23070
23071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23073 if (SWIG_arg_fail(1)) SWIG_fail;
23074 {
23075 PyThreadState* __tstate = wxPyBeginAllowThreads();
23076 (arg1)->ExitMainLoop();
23077
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 Py_INCREF(Py_None); resultobj = Py_None;
23082 return resultobj;
23083 fail:
23084 return NULL;
23085 }
23086
23087
23088 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23089 PyObject *resultobj;
23090 wxPyApp *arg1 = (wxPyApp *) 0 ;
23091 bool result;
23092 PyObject * obj0 = 0 ;
23093 char *kwnames[] = {
23094 (char *) "self", NULL
23095 };
23096
23097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23099 if (SWIG_arg_fail(1)) SWIG_fail;
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = (bool)(arg1)->Pending();
23103
23104 wxPyEndAllowThreads(__tstate);
23105 if (PyErr_Occurred()) SWIG_fail;
23106 }
23107 {
23108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23109 }
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23117 PyObject *resultobj;
23118 wxPyApp *arg1 = (wxPyApp *) 0 ;
23119 bool result;
23120 PyObject * obj0 = 0 ;
23121 char *kwnames[] = {
23122 (char *) "self", NULL
23123 };
23124
23125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23127 if (SWIG_arg_fail(1)) SWIG_fail;
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 result = (bool)(arg1)->Dispatch();
23131
23132 wxPyEndAllowThreads(__tstate);
23133 if (PyErr_Occurred()) SWIG_fail;
23134 }
23135 {
23136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23137 }
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23145 PyObject *resultobj;
23146 wxPyApp *arg1 = (wxPyApp *) 0 ;
23147 bool result;
23148 PyObject * obj0 = 0 ;
23149 char *kwnames[] = {
23150 (char *) "self", NULL
23151 };
23152
23153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23155 if (SWIG_arg_fail(1)) SWIG_fail;
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (bool)(arg1)->ProcessIdle();
23159
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 {
23164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23165 }
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23173 PyObject *resultobj;
23174 wxPyApp *arg1 = (wxPyApp *) 0 ;
23175 wxWindow *arg2 = (wxWindow *) 0 ;
23176 wxIdleEvent *arg3 = 0 ;
23177 bool result;
23178 PyObject * obj0 = 0 ;
23179 PyObject * obj1 = 0 ;
23180 PyObject * obj2 = 0 ;
23181 char *kwnames[] = {
23182 (char *) "self",(char *) "win",(char *) "event", NULL
23183 };
23184
23185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23187 if (SWIG_arg_fail(1)) SWIG_fail;
23188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23189 if (SWIG_arg_fail(2)) SWIG_fail;
23190 {
23191 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23192 if (SWIG_arg_fail(3)) SWIG_fail;
23193 if (arg3 == NULL) {
23194 SWIG_null_ref("wxIdleEvent");
23195 }
23196 if (SWIG_arg_fail(3)) SWIG_fail;
23197 }
23198 {
23199 PyThreadState* __tstate = wxPyBeginAllowThreads();
23200 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23201
23202 wxPyEndAllowThreads(__tstate);
23203 if (PyErr_Occurred()) SWIG_fail;
23204 }
23205 {
23206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23207 }
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23215 PyObject *resultobj;
23216 wxPyApp *arg1 = (wxPyApp *) 0 ;
23217 bool result;
23218 PyObject * obj0 = 0 ;
23219 char *kwnames[] = {
23220 (char *) "self", NULL
23221 };
23222
23223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23225 if (SWIG_arg_fail(1)) SWIG_fail;
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (bool)((wxPyApp const *)arg1)->IsActive();
23229
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 {
23234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23235 }
23236 return resultobj;
23237 fail:
23238 return NULL;
23239 }
23240
23241
23242 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23243 PyObject *resultobj;
23244 wxPyApp *arg1 = (wxPyApp *) 0 ;
23245 wxWindow *arg2 = (wxWindow *) 0 ;
23246 PyObject * obj0 = 0 ;
23247 PyObject * obj1 = 0 ;
23248 char *kwnames[] = {
23249 (char *) "self",(char *) "win", NULL
23250 };
23251
23252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23254 if (SWIG_arg_fail(1)) SWIG_fail;
23255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23256 if (SWIG_arg_fail(2)) SWIG_fail;
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 (arg1)->SetTopWindow(arg2);
23260
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 Py_INCREF(Py_None); resultobj = Py_None;
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23272 PyObject *resultobj;
23273 wxPyApp *arg1 = (wxPyApp *) 0 ;
23274 wxWindow *result;
23275 PyObject * obj0 = 0 ;
23276 char *kwnames[] = {
23277 (char *) "self", NULL
23278 };
23279
23280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23282 if (SWIG_arg_fail(1)) SWIG_fail;
23283 {
23284 PyThreadState* __tstate = wxPyBeginAllowThreads();
23285 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23286
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 {
23291 resultobj = wxPyMake_wxObject(result, 0);
23292 }
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23300 PyObject *resultobj;
23301 wxPyApp *arg1 = (wxPyApp *) 0 ;
23302 bool arg2 ;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char *kwnames[] = {
23306 (char *) "self",(char *) "flag", NULL
23307 };
23308
23309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23311 if (SWIG_arg_fail(1)) SWIG_fail;
23312 {
23313 arg2 = (bool)(SWIG_As_bool(obj1));
23314 if (SWIG_arg_fail(2)) SWIG_fail;
23315 }
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 (arg1)->SetExitOnFrameDelete(arg2);
23319
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 Py_INCREF(Py_None); resultobj = Py_None;
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj;
23332 wxPyApp *arg1 = (wxPyApp *) 0 ;
23333 bool result;
23334 PyObject * obj0 = 0 ;
23335 char *kwnames[] = {
23336 (char *) "self", NULL
23337 };
23338
23339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23341 if (SWIG_arg_fail(1)) SWIG_fail;
23342 {
23343 PyThreadState* __tstate = wxPyBeginAllowThreads();
23344 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23345
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 {
23350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23351 }
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23359 PyObject *resultobj;
23360 wxPyApp *arg1 = (wxPyApp *) 0 ;
23361 bool arg2 ;
23362 PyObject * obj0 = 0 ;
23363 PyObject * obj1 = 0 ;
23364 char *kwnames[] = {
23365 (char *) "self",(char *) "flag", NULL
23366 };
23367
23368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23370 if (SWIG_arg_fail(1)) SWIG_fail;
23371 {
23372 arg2 = (bool)(SWIG_As_bool(obj1));
23373 if (SWIG_arg_fail(2)) SWIG_fail;
23374 }
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 (arg1)->SetUseBestVisual(arg2);
23378
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 Py_INCREF(Py_None); resultobj = Py_None;
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23390 PyObject *resultobj;
23391 wxPyApp *arg1 = (wxPyApp *) 0 ;
23392 bool result;
23393 PyObject * obj0 = 0 ;
23394 char *kwnames[] = {
23395 (char *) "self", NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23400 if (SWIG_arg_fail(1)) SWIG_fail;
23401 {
23402 PyThreadState* __tstate = wxPyBeginAllowThreads();
23403 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23404
23405 wxPyEndAllowThreads(__tstate);
23406 if (PyErr_Occurred()) SWIG_fail;
23407 }
23408 {
23409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23410 }
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 wxPyApp *arg1 = (wxPyApp *) 0 ;
23420 int arg2 ;
23421 PyObject * obj0 = 0 ;
23422 PyObject * obj1 = 0 ;
23423 char *kwnames[] = {
23424 (char *) "self",(char *) "mode", NULL
23425 };
23426
23427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23429 if (SWIG_arg_fail(1)) SWIG_fail;
23430 {
23431 arg2 = (int)(SWIG_As_int(obj1));
23432 if (SWIG_arg_fail(2)) SWIG_fail;
23433 }
23434 {
23435 PyThreadState* __tstate = wxPyBeginAllowThreads();
23436 (arg1)->SetPrintMode(arg2);
23437
23438 wxPyEndAllowThreads(__tstate);
23439 if (PyErr_Occurred()) SWIG_fail;
23440 }
23441 Py_INCREF(Py_None); resultobj = Py_None;
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj;
23450 wxPyApp *arg1 = (wxPyApp *) 0 ;
23451 int result;
23452 PyObject * obj0 = 0 ;
23453 char *kwnames[] = {
23454 (char *) "self", NULL
23455 };
23456
23457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23459 if (SWIG_arg_fail(1)) SWIG_fail;
23460 {
23461 PyThreadState* __tstate = wxPyBeginAllowThreads();
23462 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23463
23464 wxPyEndAllowThreads(__tstate);
23465 if (PyErr_Occurred()) SWIG_fail;
23466 }
23467 {
23468 resultobj = SWIG_From_int((int)(result));
23469 }
23470 return resultobj;
23471 fail:
23472 return NULL;
23473 }
23474
23475
23476 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj;
23478 wxPyApp *arg1 = (wxPyApp *) 0 ;
23479 int arg2 ;
23480 PyObject * obj0 = 0 ;
23481 PyObject * obj1 = 0 ;
23482 char *kwnames[] = {
23483 (char *) "self",(char *) "mode", NULL
23484 };
23485
23486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23488 if (SWIG_arg_fail(1)) SWIG_fail;
23489 {
23490 arg2 = (int)(SWIG_As_int(obj1));
23491 if (SWIG_arg_fail(2)) SWIG_fail;
23492 }
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 (arg1)->SetAssertMode(arg2);
23496
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 Py_INCREF(Py_None); resultobj = Py_None;
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj;
23509 wxPyApp *arg1 = (wxPyApp *) 0 ;
23510 int result;
23511 PyObject * obj0 = 0 ;
23512 char *kwnames[] = {
23513 (char *) "self", NULL
23514 };
23515
23516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23518 if (SWIG_arg_fail(1)) SWIG_fail;
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 result = (int)(arg1)->GetAssertMode();
23522
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 resultobj = SWIG_From_int((int)(result));
23528 }
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj;
23537 bool result;
23538 char *kwnames[] = {
23539 NULL
23540 };
23541
23542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23546
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 {
23551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23552 }
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj;
23561 long result;
23562 char *kwnames[] = {
23563 NULL
23564 };
23565
23566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23567 {
23568 PyThreadState* __tstate = wxPyBeginAllowThreads();
23569 result = (long)wxPyApp::GetMacAboutMenuItemId();
23570
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 {
23575 resultobj = SWIG_From_long((long)(result));
23576 }
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj;
23585 long result;
23586 char *kwnames[] = {
23587 NULL
23588 };
23589
23590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = SWIG_From_long((long)(result));
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 long result;
23610 char *kwnames[] = {
23611 NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = (long)wxPyApp::GetMacExitMenuItemId();
23618
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 resultobj = SWIG_From_long((long)(result));
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj;
23633 wxString result;
23634 char *kwnames[] = {
23635 NULL
23636 };
23637
23638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = wxPyApp::GetMacHelpMenuTitleName();
23642
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 {
23647 #if wxUSE_UNICODE
23648 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23649 #else
23650 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23651 #endif
23652 }
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj;
23661 bool arg1 ;
23662 PyObject * obj0 = 0 ;
23663 char *kwnames[] = {
23664 (char *) "val", NULL
23665 };
23666
23667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23668 {
23669 arg1 = (bool)(SWIG_As_bool(obj0));
23670 if (SWIG_arg_fail(1)) SWIG_fail;
23671 }
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23675
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 Py_INCREF(Py_None); resultobj = Py_None;
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj;
23688 long arg1 ;
23689 PyObject * obj0 = 0 ;
23690 char *kwnames[] = {
23691 (char *) "val", NULL
23692 };
23693
23694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23695 {
23696 arg1 = (long)(SWIG_As_long(obj0));
23697 if (SWIG_arg_fail(1)) SWIG_fail;
23698 }
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 wxPyApp::SetMacAboutMenuItemId(arg1);
23702
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 Py_INCREF(Py_None); resultobj = Py_None;
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23714 PyObject *resultobj;
23715 long arg1 ;
23716 PyObject * obj0 = 0 ;
23717 char *kwnames[] = {
23718 (char *) "val", NULL
23719 };
23720
23721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23722 {
23723 arg1 = (long)(SWIG_As_long(obj0));
23724 if (SWIG_arg_fail(1)) SWIG_fail;
23725 }
23726 {
23727 PyThreadState* __tstate = wxPyBeginAllowThreads();
23728 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23729
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 Py_INCREF(Py_None); resultobj = Py_None;
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj;
23742 long arg1 ;
23743 PyObject * obj0 = 0 ;
23744 char *kwnames[] = {
23745 (char *) "val", NULL
23746 };
23747
23748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23749 {
23750 arg1 = (long)(SWIG_As_long(obj0));
23751 if (SWIG_arg_fail(1)) SWIG_fail;
23752 }
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 wxPyApp::SetMacExitMenuItemId(arg1);
23756
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 Py_INCREF(Py_None); resultobj = Py_None;
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj;
23769 wxString *arg1 = 0 ;
23770 bool temp1 = false ;
23771 PyObject * obj0 = 0 ;
23772 char *kwnames[] = {
23773 (char *) "val", NULL
23774 };
23775
23776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23777 {
23778 arg1 = wxString_in_helper(obj0);
23779 if (arg1 == NULL) SWIG_fail;
23780 temp1 = true;
23781 }
23782 {
23783 PyThreadState* __tstate = wxPyBeginAllowThreads();
23784 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23785
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 Py_INCREF(Py_None); resultobj = Py_None;
23790 {
23791 if (temp1)
23792 delete arg1;
23793 }
23794 return resultobj;
23795 fail:
23796 {
23797 if (temp1)
23798 delete arg1;
23799 }
23800 return NULL;
23801 }
23802
23803
23804 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj;
23806 wxPyApp *arg1 = (wxPyApp *) 0 ;
23807 PyObject * obj0 = 0 ;
23808 char *kwnames[] = {
23809 (char *) "self", NULL
23810 };
23811
23812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23814 if (SWIG_arg_fail(1)) SWIG_fail;
23815 {
23816 PyThreadState* __tstate = wxPyBeginAllowThreads();
23817 (arg1)->_BootstrapApp();
23818
23819 wxPyEndAllowThreads(__tstate);
23820 if (PyErr_Occurred()) SWIG_fail;
23821 }
23822 Py_INCREF(Py_None); resultobj = Py_None;
23823 return resultobj;
23824 fail:
23825 return NULL;
23826 }
23827
23828
23829 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj;
23831 int result;
23832 char *kwnames[] = {
23833 NULL
23834 };
23835
23836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = (int)PyApp_GetComCtl32Version();
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 {
23845 resultobj = SWIG_From_int((int)(result));
23846 }
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23854 PyObject *obj;
23855 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23856 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23857 Py_INCREF(obj);
23858 return Py_BuildValue((char *)"");
23859 }
23860 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23861 PyObject *resultobj;
23862 char *kwnames[] = {
23863 NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 wxExit();
23870
23871 wxPyEndAllowThreads(__tstate);
23872 if (PyErr_Occurred()) SWIG_fail;
23873 }
23874 Py_INCREF(Py_None); resultobj = Py_None;
23875 return resultobj;
23876 fail:
23877 return NULL;
23878 }
23879
23880
23881 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23882 PyObject *resultobj;
23883 bool result;
23884 char *kwnames[] = {
23885 NULL
23886 };
23887
23888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23889 {
23890 PyThreadState* __tstate = wxPyBeginAllowThreads();
23891 result = (bool)wxYield();
23892
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 {
23897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23898 }
23899 return resultobj;
23900 fail:
23901 return NULL;
23902 }
23903
23904
23905 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23906 PyObject *resultobj;
23907 bool result;
23908 char *kwnames[] = {
23909 NULL
23910 };
23911
23912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = (bool)wxYieldIfNeeded();
23916
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 wxWindow *arg1 = (wxWindow *) NULL ;
23932 bool arg2 = (bool) false ;
23933 bool result;
23934 PyObject * obj0 = 0 ;
23935 PyObject * obj1 = 0 ;
23936 char *kwnames[] = {
23937 (char *) "win",(char *) "onlyIfNeeded", NULL
23938 };
23939
23940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23941 if (obj0) {
23942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23943 if (SWIG_arg_fail(1)) SWIG_fail;
23944 }
23945 if (obj1) {
23946 {
23947 arg2 = (bool)(SWIG_As_bool(obj1));
23948 if (SWIG_arg_fail(2)) SWIG_fail;
23949 }
23950 }
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = (bool)wxSafeYield(arg1,arg2);
23954
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 {
23959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23960 }
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj;
23969 char *kwnames[] = {
23970 NULL
23971 };
23972
23973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 wxWakeUpIdle();
23977
23978 wxPyEndAllowThreads(__tstate);
23979 if (PyErr_Occurred()) SWIG_fail;
23980 }
23981 Py_INCREF(Py_None); resultobj = Py_None;
23982 return resultobj;
23983 fail:
23984 return NULL;
23985 }
23986
23987
23988 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj;
23990 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23991 wxEvent *arg2 = 0 ;
23992 PyObject * obj0 = 0 ;
23993 PyObject * obj1 = 0 ;
23994 char *kwnames[] = {
23995 (char *) "dest",(char *) "event", NULL
23996 };
23997
23998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24000 if (SWIG_arg_fail(1)) SWIG_fail;
24001 {
24002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24003 if (SWIG_arg_fail(2)) SWIG_fail;
24004 if (arg2 == NULL) {
24005 SWIG_null_ref("wxEvent");
24006 }
24007 if (SWIG_arg_fail(2)) SWIG_fail;
24008 }
24009 {
24010 PyThreadState* __tstate = wxPyBeginAllowThreads();
24011 wxPostEvent(arg1,*arg2);
24012
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 Py_INCREF(Py_None); resultobj = Py_None;
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24024 PyObject *resultobj;
24025 char *kwnames[] = {
24026 NULL
24027 };
24028
24029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24030 {
24031 PyThreadState* __tstate = wxPyBeginAllowThreads();
24032 wxApp_CleanUp();
24033
24034 wxPyEndAllowThreads(__tstate);
24035 if (PyErr_Occurred()) SWIG_fail;
24036 }
24037 Py_INCREF(Py_None); resultobj = Py_None;
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24045 PyObject *resultobj;
24046 wxPyApp *result;
24047 char *kwnames[] = {
24048 NULL
24049 };
24050
24051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24052 {
24053 PyThreadState* __tstate = wxPyBeginAllowThreads();
24054 result = (wxPyApp *)wxPyGetApp();
24055
24056 wxPyEndAllowThreads(__tstate);
24057 if (PyErr_Occurred()) SWIG_fail;
24058 }
24059 {
24060 resultobj = wxPyMake_wxObject(result, 0);
24061 }
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24069 PyObject *resultobj;
24070 char *arg1 = (char *) 0 ;
24071 PyObject * obj0 = 0 ;
24072 char *kwnames[] = {
24073 (char *) "encoding", NULL
24074 };
24075
24076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24077 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24078 SWIG_arg_fail(1);SWIG_fail;
24079 }
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 wxSetDefaultPyEncoding((char const *)arg1);
24083
24084 wxPyEndAllowThreads(__tstate);
24085 if (PyErr_Occurred()) SWIG_fail;
24086 }
24087 Py_INCREF(Py_None); resultobj = Py_None;
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24095 PyObject *resultobj;
24096 char *result;
24097 char *kwnames[] = {
24098 NULL
24099 };
24100
24101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 result = (char *)wxGetDefaultPyEncoding();
24105
24106 wxPyEndAllowThreads(__tstate);
24107 if (PyErr_Occurred()) SWIG_fail;
24108 }
24109 resultobj = SWIG_FromCharPtr(result);
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxEventLoop *result;
24119 char *kwnames[] = {
24120 NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (wxEventLoop *)new wxEventLoop();
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj;
24140 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24141 PyObject * obj0 = 0 ;
24142 char *kwnames[] = {
24143 (char *) "self", NULL
24144 };
24145
24146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24148 if (SWIG_arg_fail(1)) SWIG_fail;
24149 {
24150 PyThreadState* __tstate = wxPyBeginAllowThreads();
24151 delete arg1;
24152
24153 wxPyEndAllowThreads(__tstate);
24154 if (PyErr_Occurred()) SWIG_fail;
24155 }
24156 Py_INCREF(Py_None); resultobj = Py_None;
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj;
24165 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24166 int result;
24167 PyObject * obj0 = 0 ;
24168 char *kwnames[] = {
24169 (char *) "self", NULL
24170 };
24171
24172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24174 if (SWIG_arg_fail(1)) SWIG_fail;
24175 {
24176 PyThreadState* __tstate = wxPyBeginAllowThreads();
24177 result = (int)(arg1)->Run();
24178
24179 wxPyEndAllowThreads(__tstate);
24180 if (PyErr_Occurred()) SWIG_fail;
24181 }
24182 {
24183 resultobj = SWIG_From_int((int)(result));
24184 }
24185 return resultobj;
24186 fail:
24187 return NULL;
24188 }
24189
24190
24191 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24192 PyObject *resultobj;
24193 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24194 int arg2 = (int) 0 ;
24195 PyObject * obj0 = 0 ;
24196 PyObject * obj1 = 0 ;
24197 char *kwnames[] = {
24198 (char *) "self",(char *) "rc", NULL
24199 };
24200
24201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24203 if (SWIG_arg_fail(1)) SWIG_fail;
24204 if (obj1) {
24205 {
24206 arg2 = (int)(SWIG_As_int(obj1));
24207 if (SWIG_arg_fail(2)) SWIG_fail;
24208 }
24209 }
24210 {
24211 PyThreadState* __tstate = wxPyBeginAllowThreads();
24212 (arg1)->Exit(arg2);
24213
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 Py_INCREF(Py_None); resultobj = Py_None;
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj;
24226 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24227 bool result;
24228 PyObject * obj0 = 0 ;
24229 char *kwnames[] = {
24230 (char *) "self", NULL
24231 };
24232
24233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24235 if (SWIG_arg_fail(1)) SWIG_fail;
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 result = (bool)((wxEventLoop const *)arg1)->Pending();
24239
24240 wxPyEndAllowThreads(__tstate);
24241 if (PyErr_Occurred()) SWIG_fail;
24242 }
24243 {
24244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24245 }
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24253 PyObject *resultobj;
24254 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24255 bool result;
24256 PyObject * obj0 = 0 ;
24257 char *kwnames[] = {
24258 (char *) "self", NULL
24259 };
24260
24261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24263 if (SWIG_arg_fail(1)) SWIG_fail;
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (bool)(arg1)->Dispatch();
24267
24268 wxPyEndAllowThreads(__tstate);
24269 if (PyErr_Occurred()) SWIG_fail;
24270 }
24271 {
24272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24281 PyObject *resultobj;
24282 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24283 bool result;
24284 PyObject * obj0 = 0 ;
24285 char *kwnames[] = {
24286 (char *) "self", NULL
24287 };
24288
24289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24291 if (SWIG_arg_fail(1)) SWIG_fail;
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24295
24296 wxPyEndAllowThreads(__tstate);
24297 if (PyErr_Occurred()) SWIG_fail;
24298 }
24299 {
24300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24301 }
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj;
24310 wxEventLoop *result;
24311 char *kwnames[] = {
24312 NULL
24313 };
24314
24315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24316 {
24317 PyThreadState* __tstate = wxPyBeginAllowThreads();
24318 result = (wxEventLoop *)wxEventLoop::GetActive();
24319
24320 wxPyEndAllowThreads(__tstate);
24321 if (PyErr_Occurred()) SWIG_fail;
24322 }
24323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24324 return resultobj;
24325 fail:
24326 return NULL;
24327 }
24328
24329
24330 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24331 PyObject *resultobj;
24332 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24333 PyObject * obj0 = 0 ;
24334 char *kwnames[] = {
24335 (char *) "loop", NULL
24336 };
24337
24338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24340 if (SWIG_arg_fail(1)) SWIG_fail;
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 wxEventLoop::SetActive(arg1);
24344
24345 wxPyEndAllowThreads(__tstate);
24346 if (PyErr_Occurred()) SWIG_fail;
24347 }
24348 Py_INCREF(Py_None); resultobj = Py_None;
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24356 PyObject *obj;
24357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24358 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24359 Py_INCREF(obj);
24360 return Py_BuildValue((char *)"");
24361 }
24362 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24363 PyObject *resultobj;
24364 int arg1 = (int) 0 ;
24365 int arg2 = (int) 0 ;
24366 int arg3 = (int) 0 ;
24367 wxAcceleratorEntry *result;
24368 PyObject * obj0 = 0 ;
24369 PyObject * obj1 = 0 ;
24370 PyObject * obj2 = 0 ;
24371 char *kwnames[] = {
24372 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24373 };
24374
24375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24376 if (obj0) {
24377 {
24378 arg1 = (int)(SWIG_As_int(obj0));
24379 if (SWIG_arg_fail(1)) SWIG_fail;
24380 }
24381 }
24382 if (obj1) {
24383 {
24384 arg2 = (int)(SWIG_As_int(obj1));
24385 if (SWIG_arg_fail(2)) SWIG_fail;
24386 }
24387 }
24388 if (obj2) {
24389 {
24390 arg3 = (int)(SWIG_As_int(obj2));
24391 if (SWIG_arg_fail(3)) SWIG_fail;
24392 }
24393 }
24394 {
24395 PyThreadState* __tstate = wxPyBeginAllowThreads();
24396 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24397
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj;
24410 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24411 PyObject * obj0 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 delete arg1;
24422
24423 wxPyEndAllowThreads(__tstate);
24424 if (PyErr_Occurred()) SWIG_fail;
24425 }
24426 Py_INCREF(Py_None); resultobj = Py_None;
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24434 PyObject *resultobj;
24435 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24436 int arg2 ;
24437 int arg3 ;
24438 int arg4 ;
24439 PyObject * obj0 = 0 ;
24440 PyObject * obj1 = 0 ;
24441 PyObject * obj2 = 0 ;
24442 PyObject * obj3 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 {
24451 arg2 = (int)(SWIG_As_int(obj1));
24452 if (SWIG_arg_fail(2)) SWIG_fail;
24453 }
24454 {
24455 arg3 = (int)(SWIG_As_int(obj2));
24456 if (SWIG_arg_fail(3)) SWIG_fail;
24457 }
24458 {
24459 arg4 = (int)(SWIG_As_int(obj3));
24460 if (SWIG_arg_fail(4)) SWIG_fail;
24461 }
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 (arg1)->Set(arg2,arg3,arg4);
24465
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 Py_INCREF(Py_None); resultobj = Py_None;
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj;
24478 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24479 int result;
24480 PyObject * obj0 = 0 ;
24481 char *kwnames[] = {
24482 (char *) "self", NULL
24483 };
24484
24485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24487 if (SWIG_arg_fail(1)) SWIG_fail;
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = (int)(arg1)->GetFlags();
24491
24492 wxPyEndAllowThreads(__tstate);
24493 if (PyErr_Occurred()) SWIG_fail;
24494 }
24495 {
24496 resultobj = SWIG_From_int((int)(result));
24497 }
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24505 PyObject *resultobj;
24506 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24507 int result;
24508 PyObject * obj0 = 0 ;
24509 char *kwnames[] = {
24510 (char *) "self", NULL
24511 };
24512
24513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(1)) SWIG_fail;
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 result = (int)(arg1)->GetKeyCode();
24519
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 {
24524 resultobj = SWIG_From_int((int)(result));
24525 }
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24533 PyObject *resultobj;
24534 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24535 int result;
24536 PyObject * obj0 = 0 ;
24537 char *kwnames[] = {
24538 (char *) "self", NULL
24539 };
24540
24541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24543 if (SWIG_arg_fail(1)) SWIG_fail;
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 result = (int)(arg1)->GetCommand();
24547
24548 wxPyEndAllowThreads(__tstate);
24549 if (PyErr_Occurred()) SWIG_fail;
24550 }
24551 {
24552 resultobj = SWIG_From_int((int)(result));
24553 }
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24561 PyObject *obj;
24562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24563 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24564 Py_INCREF(obj);
24565 return Py_BuildValue((char *)"");
24566 }
24567 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24568 PyObject *resultobj;
24569 int arg1 ;
24570 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24571 wxAcceleratorTable *result;
24572 PyObject * obj0 = 0 ;
24573 char *kwnames[] = {
24574 (char *) "n", NULL
24575 };
24576
24577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24578 {
24579 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24580 if (arg2) arg1 = PyList_Size(obj0);
24581 else arg1 = 0;
24582 }
24583 {
24584 PyThreadState* __tstate = wxPyBeginAllowThreads();
24585 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24586
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24591 {
24592 delete [] arg2;
24593 }
24594 return resultobj;
24595 fail:
24596 {
24597 delete [] arg2;
24598 }
24599 return NULL;
24600 }
24601
24602
24603 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj;
24605 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24606 PyObject * obj0 = 0 ;
24607 char *kwnames[] = {
24608 (char *) "self", NULL
24609 };
24610
24611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24613 if (SWIG_arg_fail(1)) SWIG_fail;
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 delete arg1;
24617
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 Py_INCREF(Py_None); resultobj = Py_None;
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24629 PyObject *resultobj;
24630 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24631 bool result;
24632 PyObject * obj0 = 0 ;
24633 char *kwnames[] = {
24634 (char *) "self", NULL
24635 };
24636
24637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24639 if (SWIG_arg_fail(1)) SWIG_fail;
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24643
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 {
24648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24649 }
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24657 PyObject *obj;
24658 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24659 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24660 Py_INCREF(obj);
24661 return Py_BuildValue((char *)"");
24662 }
24663 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24664 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24665 return 1;
24666 }
24667
24668
24669 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24670 PyObject *pyobj;
24671
24672 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24673 return pyobj;
24674 }
24675
24676
24677 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24678 PyObject *resultobj;
24679 wxString *arg1 = 0 ;
24680 wxAcceleratorEntry *result;
24681 bool temp1 = false ;
24682 PyObject * obj0 = 0 ;
24683 char *kwnames[] = {
24684 (char *) "label", NULL
24685 };
24686
24687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24688 {
24689 arg1 = wxString_in_helper(obj0);
24690 if (arg1 == NULL) SWIG_fail;
24691 temp1 = true;
24692 }
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24696
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24701 {
24702 if (temp1)
24703 delete arg1;
24704 }
24705 return resultobj;
24706 fail:
24707 {
24708 if (temp1)
24709 delete arg1;
24710 }
24711 return NULL;
24712 }
24713
24714
24715 static int _wrap_PanelNameStr_set(PyObject *) {
24716 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24717 return 1;
24718 }
24719
24720
24721 static PyObject *_wrap_PanelNameStr_get(void) {
24722 PyObject *pyobj;
24723
24724 {
24725 #if wxUSE_UNICODE
24726 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24727 #else
24728 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24729 #endif
24730 }
24731 return pyobj;
24732 }
24733
24734
24735 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24736 PyObject *resultobj;
24737 wxVisualAttributes *result;
24738 char *kwnames[] = {
24739 NULL
24740 };
24741
24742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 result = (wxVisualAttributes *)new_wxVisualAttributes();
24746
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24758 PyObject *resultobj;
24759 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24760 PyObject * obj0 = 0 ;
24761 char *kwnames[] = {
24762 (char *) "self", NULL
24763 };
24764
24765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24767 if (SWIG_arg_fail(1)) SWIG_fail;
24768 {
24769 PyThreadState* __tstate = wxPyBeginAllowThreads();
24770 delete_wxVisualAttributes(arg1);
24771
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 Py_INCREF(Py_None); resultobj = Py_None;
24776 return resultobj;
24777 fail:
24778 return NULL;
24779 }
24780
24781
24782 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj;
24784 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24785 wxFont *arg2 = (wxFont *) 0 ;
24786 PyObject * obj0 = 0 ;
24787 PyObject * obj1 = 0 ;
24788 char *kwnames[] = {
24789 (char *) "self",(char *) "font", NULL
24790 };
24791
24792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24794 if (SWIG_arg_fail(1)) SWIG_fail;
24795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24796 if (SWIG_arg_fail(2)) SWIG_fail;
24797 if (arg1) (arg1)->font = *arg2;
24798
24799 Py_INCREF(Py_None); resultobj = Py_None;
24800 return resultobj;
24801 fail:
24802 return NULL;
24803 }
24804
24805
24806 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24807 PyObject *resultobj;
24808 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24809 wxFont *result;
24810 PyObject * obj0 = 0 ;
24811 char *kwnames[] = {
24812 (char *) "self", NULL
24813 };
24814
24815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24817 if (SWIG_arg_fail(1)) SWIG_fail;
24818 result = (wxFont *)& ((arg1)->font);
24819
24820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24821 return resultobj;
24822 fail:
24823 return NULL;
24824 }
24825
24826
24827 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24828 PyObject *resultobj;
24829 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24830 wxColour *arg2 = (wxColour *) 0 ;
24831 PyObject * obj0 = 0 ;
24832 PyObject * obj1 = 0 ;
24833 char *kwnames[] = {
24834 (char *) "self",(char *) "colFg", NULL
24835 };
24836
24837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(1)) SWIG_fail;
24840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24841 if (SWIG_arg_fail(2)) SWIG_fail;
24842 if (arg1) (arg1)->colFg = *arg2;
24843
24844 Py_INCREF(Py_None); resultobj = Py_None;
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24852 PyObject *resultobj;
24853 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24854 wxColour *result;
24855 PyObject * obj0 = 0 ;
24856 char *kwnames[] = {
24857 (char *) "self", NULL
24858 };
24859
24860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24862 if (SWIG_arg_fail(1)) SWIG_fail;
24863 result = (wxColour *)& ((arg1)->colFg);
24864
24865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24873 PyObject *resultobj;
24874 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24875 wxColour *arg2 = (wxColour *) 0 ;
24876 PyObject * obj0 = 0 ;
24877 PyObject * obj1 = 0 ;
24878 char *kwnames[] = {
24879 (char *) "self",(char *) "colBg", NULL
24880 };
24881
24882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24884 if (SWIG_arg_fail(1)) SWIG_fail;
24885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24886 if (SWIG_arg_fail(2)) SWIG_fail;
24887 if (arg1) (arg1)->colBg = *arg2;
24888
24889 Py_INCREF(Py_None); resultobj = Py_None;
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24897 PyObject *resultobj;
24898 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24899 wxColour *result;
24900 PyObject * obj0 = 0 ;
24901 char *kwnames[] = {
24902 (char *) "self", NULL
24903 };
24904
24905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24907 if (SWIG_arg_fail(1)) SWIG_fail;
24908 result = (wxColour *)& ((arg1)->colBg);
24909
24910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24918 PyObject *obj;
24919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24920 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24921 Py_INCREF(obj);
24922 return Py_BuildValue((char *)"");
24923 }
24924 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24925 PyObject *resultobj;
24926 wxWindow *arg1 = (wxWindow *) 0 ;
24927 int arg2 = (int) (int)-1 ;
24928 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24929 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24930 wxSize const &arg4_defvalue = wxDefaultSize ;
24931 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24932 long arg5 = (long) 0 ;
24933 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24934 wxString *arg6 = (wxString *) &arg6_defvalue ;
24935 wxWindow *result;
24936 wxPoint temp3 ;
24937 wxSize temp4 ;
24938 bool temp6 = false ;
24939 PyObject * obj0 = 0 ;
24940 PyObject * obj1 = 0 ;
24941 PyObject * obj2 = 0 ;
24942 PyObject * obj3 = 0 ;
24943 PyObject * obj4 = 0 ;
24944 PyObject * obj5 = 0 ;
24945 char *kwnames[] = {
24946 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24947 };
24948
24949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24951 if (SWIG_arg_fail(1)) SWIG_fail;
24952 if (obj1) {
24953 {
24954 arg2 = (int const)(SWIG_As_int(obj1));
24955 if (SWIG_arg_fail(2)) SWIG_fail;
24956 }
24957 }
24958 if (obj2) {
24959 {
24960 arg3 = &temp3;
24961 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24962 }
24963 }
24964 if (obj3) {
24965 {
24966 arg4 = &temp4;
24967 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24968 }
24969 }
24970 if (obj4) {
24971 {
24972 arg5 = (long)(SWIG_As_long(obj4));
24973 if (SWIG_arg_fail(5)) SWIG_fail;
24974 }
24975 }
24976 if (obj5) {
24977 {
24978 arg6 = wxString_in_helper(obj5);
24979 if (arg6 == NULL) SWIG_fail;
24980 temp6 = true;
24981 }
24982 }
24983 {
24984 if (!wxPyCheckForApp()) SWIG_fail;
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24987
24988 wxPyEndAllowThreads(__tstate);
24989 if (PyErr_Occurred()) SWIG_fail;
24990 }
24991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24992 {
24993 if (temp6)
24994 delete arg6;
24995 }
24996 return resultobj;
24997 fail:
24998 {
24999 if (temp6)
25000 delete arg6;
25001 }
25002 return NULL;
25003 }
25004
25005
25006 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25007 PyObject *resultobj;
25008 wxWindow *result;
25009 char *kwnames[] = {
25010 NULL
25011 };
25012
25013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25014 {
25015 if (!wxPyCheckForApp()) SWIG_fail;
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 result = (wxWindow *)new wxWindow();
25018
25019 wxPyEndAllowThreads(__tstate);
25020 if (PyErr_Occurred()) SWIG_fail;
25021 }
25022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25030 PyObject *resultobj;
25031 wxWindow *arg1 = (wxWindow *) 0 ;
25032 wxWindow *arg2 = (wxWindow *) 0 ;
25033 int arg3 = (int) (int)-1 ;
25034 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25035 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25036 wxSize const &arg5_defvalue = wxDefaultSize ;
25037 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25038 long arg6 = (long) 0 ;
25039 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25040 wxString *arg7 = (wxString *) &arg7_defvalue ;
25041 bool result;
25042 wxPoint temp4 ;
25043 wxSize temp5 ;
25044 bool temp7 = false ;
25045 PyObject * obj0 = 0 ;
25046 PyObject * obj1 = 0 ;
25047 PyObject * obj2 = 0 ;
25048 PyObject * obj3 = 0 ;
25049 PyObject * obj4 = 0 ;
25050 PyObject * obj5 = 0 ;
25051 PyObject * obj6 = 0 ;
25052 char *kwnames[] = {
25053 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25054 };
25055
25056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25058 if (SWIG_arg_fail(1)) SWIG_fail;
25059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25060 if (SWIG_arg_fail(2)) SWIG_fail;
25061 if (obj2) {
25062 {
25063 arg3 = (int const)(SWIG_As_int(obj2));
25064 if (SWIG_arg_fail(3)) SWIG_fail;
25065 }
25066 }
25067 if (obj3) {
25068 {
25069 arg4 = &temp4;
25070 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25071 }
25072 }
25073 if (obj4) {
25074 {
25075 arg5 = &temp5;
25076 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25077 }
25078 }
25079 if (obj5) {
25080 {
25081 arg6 = (long)(SWIG_As_long(obj5));
25082 if (SWIG_arg_fail(6)) SWIG_fail;
25083 }
25084 }
25085 if (obj6) {
25086 {
25087 arg7 = wxString_in_helper(obj6);
25088 if (arg7 == NULL) SWIG_fail;
25089 temp7 = true;
25090 }
25091 }
25092 {
25093 PyThreadState* __tstate = wxPyBeginAllowThreads();
25094 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25095
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 {
25100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25101 }
25102 {
25103 if (temp7)
25104 delete arg7;
25105 }
25106 return resultobj;
25107 fail:
25108 {
25109 if (temp7)
25110 delete arg7;
25111 }
25112 return NULL;
25113 }
25114
25115
25116 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25117 PyObject *resultobj;
25118 wxWindow *arg1 = (wxWindow *) 0 ;
25119 bool arg2 = (bool) false ;
25120 bool result;
25121 PyObject * obj0 = 0 ;
25122 PyObject * obj1 = 0 ;
25123 char *kwnames[] = {
25124 (char *) "self",(char *) "force", NULL
25125 };
25126
25127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25129 if (SWIG_arg_fail(1)) SWIG_fail;
25130 if (obj1) {
25131 {
25132 arg2 = (bool)(SWIG_As_bool(obj1));
25133 if (SWIG_arg_fail(2)) SWIG_fail;
25134 }
25135 }
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (bool)(arg1)->Close(arg2);
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 {
25144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25145 }
25146 return resultobj;
25147 fail:
25148 return NULL;
25149 }
25150
25151
25152 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj;
25154 wxWindow *arg1 = (wxWindow *) 0 ;
25155 bool result;
25156 PyObject * obj0 = 0 ;
25157 char *kwnames[] = {
25158 (char *) "self", NULL
25159 };
25160
25161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25163 if (SWIG_arg_fail(1)) SWIG_fail;
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = (bool)(arg1)->Destroy();
25167
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25173 }
25174 return resultobj;
25175 fail:
25176 return NULL;
25177 }
25178
25179
25180 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25181 PyObject *resultobj;
25182 wxWindow *arg1 = (wxWindow *) 0 ;
25183 bool result;
25184 PyObject * obj0 = 0 ;
25185 char *kwnames[] = {
25186 (char *) "self", NULL
25187 };
25188
25189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25191 if (SWIG_arg_fail(1)) SWIG_fail;
25192 {
25193 PyThreadState* __tstate = wxPyBeginAllowThreads();
25194 result = (bool)(arg1)->DestroyChildren();
25195
25196 wxPyEndAllowThreads(__tstate);
25197 if (PyErr_Occurred()) SWIG_fail;
25198 }
25199 {
25200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25201 }
25202 return resultobj;
25203 fail:
25204 return NULL;
25205 }
25206
25207
25208 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25209 PyObject *resultobj;
25210 wxWindow *arg1 = (wxWindow *) 0 ;
25211 bool result;
25212 PyObject * obj0 = 0 ;
25213 char *kwnames[] = {
25214 (char *) "self", NULL
25215 };
25216
25217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25219 if (SWIG_arg_fail(1)) SWIG_fail;
25220 {
25221 PyThreadState* __tstate = wxPyBeginAllowThreads();
25222 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25223
25224 wxPyEndAllowThreads(__tstate);
25225 if (PyErr_Occurred()) SWIG_fail;
25226 }
25227 {
25228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25229 }
25230 return resultobj;
25231 fail:
25232 return NULL;
25233 }
25234
25235
25236 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25237 PyObject *resultobj;
25238 wxWindow *arg1 = (wxWindow *) 0 ;
25239 wxString *arg2 = 0 ;
25240 bool temp2 = false ;
25241 PyObject * obj0 = 0 ;
25242 PyObject * obj1 = 0 ;
25243 char *kwnames[] = {
25244 (char *) "self",(char *) "title", NULL
25245 };
25246
25247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25249 if (SWIG_arg_fail(1)) SWIG_fail;
25250 {
25251 arg2 = wxString_in_helper(obj1);
25252 if (arg2 == NULL) SWIG_fail;
25253 temp2 = true;
25254 }
25255 {
25256 PyThreadState* __tstate = wxPyBeginAllowThreads();
25257 (arg1)->SetTitle((wxString const &)*arg2);
25258
25259 wxPyEndAllowThreads(__tstate);
25260 if (PyErr_Occurred()) SWIG_fail;
25261 }
25262 Py_INCREF(Py_None); resultobj = Py_None;
25263 {
25264 if (temp2)
25265 delete arg2;
25266 }
25267 return resultobj;
25268 fail:
25269 {
25270 if (temp2)
25271 delete arg2;
25272 }
25273 return NULL;
25274 }
25275
25276
25277 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25278 PyObject *resultobj;
25279 wxWindow *arg1 = (wxWindow *) 0 ;
25280 wxString result;
25281 PyObject * obj0 = 0 ;
25282 char *kwnames[] = {
25283 (char *) "self", NULL
25284 };
25285
25286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25288 if (SWIG_arg_fail(1)) SWIG_fail;
25289 {
25290 PyThreadState* __tstate = wxPyBeginAllowThreads();
25291 result = ((wxWindow const *)arg1)->GetTitle();
25292
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 {
25297 #if wxUSE_UNICODE
25298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25299 #else
25300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25301 #endif
25302 }
25303 return resultobj;
25304 fail:
25305 return NULL;
25306 }
25307
25308
25309 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25310 PyObject *resultobj;
25311 wxWindow *arg1 = (wxWindow *) 0 ;
25312 wxString *arg2 = 0 ;
25313 bool temp2 = false ;
25314 PyObject * obj0 = 0 ;
25315 PyObject * obj1 = 0 ;
25316 char *kwnames[] = {
25317 (char *) "self",(char *) "label", NULL
25318 };
25319
25320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25322 if (SWIG_arg_fail(1)) SWIG_fail;
25323 {
25324 arg2 = wxString_in_helper(obj1);
25325 if (arg2 == NULL) SWIG_fail;
25326 temp2 = true;
25327 }
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 (arg1)->SetLabel((wxString const &)*arg2);
25331
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 Py_INCREF(Py_None); resultobj = Py_None;
25336 {
25337 if (temp2)
25338 delete arg2;
25339 }
25340 return resultobj;
25341 fail:
25342 {
25343 if (temp2)
25344 delete arg2;
25345 }
25346 return NULL;
25347 }
25348
25349
25350 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj;
25352 wxWindow *arg1 = (wxWindow *) 0 ;
25353 wxString result;
25354 PyObject * obj0 = 0 ;
25355 char *kwnames[] = {
25356 (char *) "self", NULL
25357 };
25358
25359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25361 if (SWIG_arg_fail(1)) SWIG_fail;
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = ((wxWindow const *)arg1)->GetLabel();
25365
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 {
25370 #if wxUSE_UNICODE
25371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25372 #else
25373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25374 #endif
25375 }
25376 return resultobj;
25377 fail:
25378 return NULL;
25379 }
25380
25381
25382 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25383 PyObject *resultobj;
25384 wxWindow *arg1 = (wxWindow *) 0 ;
25385 wxString *arg2 = 0 ;
25386 bool temp2 = false ;
25387 PyObject * obj0 = 0 ;
25388 PyObject * obj1 = 0 ;
25389 char *kwnames[] = {
25390 (char *) "self",(char *) "name", NULL
25391 };
25392
25393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25395 if (SWIG_arg_fail(1)) SWIG_fail;
25396 {
25397 arg2 = wxString_in_helper(obj1);
25398 if (arg2 == NULL) SWIG_fail;
25399 temp2 = true;
25400 }
25401 {
25402 PyThreadState* __tstate = wxPyBeginAllowThreads();
25403 (arg1)->SetName((wxString const &)*arg2);
25404
25405 wxPyEndAllowThreads(__tstate);
25406 if (PyErr_Occurred()) SWIG_fail;
25407 }
25408 Py_INCREF(Py_None); resultobj = Py_None;
25409 {
25410 if (temp2)
25411 delete arg2;
25412 }
25413 return resultobj;
25414 fail:
25415 {
25416 if (temp2)
25417 delete arg2;
25418 }
25419 return NULL;
25420 }
25421
25422
25423 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25424 PyObject *resultobj;
25425 wxWindow *arg1 = (wxWindow *) 0 ;
25426 wxString result;
25427 PyObject * obj0 = 0 ;
25428 char *kwnames[] = {
25429 (char *) "self", NULL
25430 };
25431
25432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25434 if (SWIG_arg_fail(1)) SWIG_fail;
25435 {
25436 PyThreadState* __tstate = wxPyBeginAllowThreads();
25437 result = ((wxWindow const *)arg1)->GetName();
25438
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 {
25443 #if wxUSE_UNICODE
25444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25445 #else
25446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25447 #endif
25448 }
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25456 PyObject *resultobj;
25457 wxWindow *arg1 = (wxWindow *) 0 ;
25458 wxWindowVariant arg2 ;
25459 PyObject * obj0 = 0 ;
25460 PyObject * obj1 = 0 ;
25461 char *kwnames[] = {
25462 (char *) "self",(char *) "variant", NULL
25463 };
25464
25465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25467 if (SWIG_arg_fail(1)) SWIG_fail;
25468 {
25469 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25470 if (SWIG_arg_fail(2)) SWIG_fail;
25471 }
25472 {
25473 PyThreadState* __tstate = wxPyBeginAllowThreads();
25474 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25475
25476 wxPyEndAllowThreads(__tstate);
25477 if (PyErr_Occurred()) SWIG_fail;
25478 }
25479 Py_INCREF(Py_None); resultobj = Py_None;
25480 return resultobj;
25481 fail:
25482 return NULL;
25483 }
25484
25485
25486 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25487 PyObject *resultobj;
25488 wxWindow *arg1 = (wxWindow *) 0 ;
25489 wxWindowVariant result;
25490 PyObject * obj0 = 0 ;
25491 char *kwnames[] = {
25492 (char *) "self", NULL
25493 };
25494
25495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25497 if (SWIG_arg_fail(1)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25501
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 resultobj = SWIG_From_int((result));
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25513 PyObject *resultobj;
25514 wxWindow *arg1 = (wxWindow *) 0 ;
25515 int arg2 ;
25516 PyObject * obj0 = 0 ;
25517 PyObject * obj1 = 0 ;
25518 char *kwnames[] = {
25519 (char *) "self",(char *) "winid", NULL
25520 };
25521
25522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25524 if (SWIG_arg_fail(1)) SWIG_fail;
25525 {
25526 arg2 = (int)(SWIG_As_int(obj1));
25527 if (SWIG_arg_fail(2)) SWIG_fail;
25528 }
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 (arg1)->SetId(arg2);
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_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25544 PyObject *resultobj;
25545 wxWindow *arg1 = (wxWindow *) 0 ;
25546 int result;
25547 PyObject * obj0 = 0 ;
25548 char *kwnames[] = {
25549 (char *) "self", NULL
25550 };
25551
25552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25554 if (SWIG_arg_fail(1)) SWIG_fail;
25555 {
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 result = (int)((wxWindow const *)arg1)->GetId();
25558
25559 wxPyEndAllowThreads(__tstate);
25560 if (PyErr_Occurred()) SWIG_fail;
25561 }
25562 {
25563 resultobj = SWIG_From_int((int)(result));
25564 }
25565 return resultobj;
25566 fail:
25567 return NULL;
25568 }
25569
25570
25571 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25572 PyObject *resultobj;
25573 int result;
25574 char *kwnames[] = {
25575 NULL
25576 };
25577
25578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25579 {
25580 PyThreadState* __tstate = wxPyBeginAllowThreads();
25581 result = (int)wxWindow::NewControlId();
25582
25583 wxPyEndAllowThreads(__tstate);
25584 if (PyErr_Occurred()) SWIG_fail;
25585 }
25586 {
25587 resultobj = SWIG_From_int((int)(result));
25588 }
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25596 PyObject *resultobj;
25597 int arg1 ;
25598 int result;
25599 PyObject * obj0 = 0 ;
25600 char *kwnames[] = {
25601 (char *) "winid", NULL
25602 };
25603
25604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25605 {
25606 arg1 = (int)(SWIG_As_int(obj0));
25607 if (SWIG_arg_fail(1)) SWIG_fail;
25608 }
25609 {
25610 PyThreadState* __tstate = wxPyBeginAllowThreads();
25611 result = (int)wxWindow::NextControlId(arg1);
25612
25613 wxPyEndAllowThreads(__tstate);
25614 if (PyErr_Occurred()) SWIG_fail;
25615 }
25616 {
25617 resultobj = SWIG_From_int((int)(result));
25618 }
25619 return resultobj;
25620 fail:
25621 return NULL;
25622 }
25623
25624
25625 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25626 PyObject *resultobj;
25627 int arg1 ;
25628 int result;
25629 PyObject * obj0 = 0 ;
25630 char *kwnames[] = {
25631 (char *) "winid", NULL
25632 };
25633
25634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25635 {
25636 arg1 = (int)(SWIG_As_int(obj0));
25637 if (SWIG_arg_fail(1)) SWIG_fail;
25638 }
25639 {
25640 PyThreadState* __tstate = wxPyBeginAllowThreads();
25641 result = (int)wxWindow::PrevControlId(arg1);
25642
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 {
25647 resultobj = SWIG_From_int((int)(result));
25648 }
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25656 PyObject *resultobj;
25657 wxWindow *arg1 = (wxWindow *) 0 ;
25658 wxSize *arg2 = 0 ;
25659 wxSize temp2 ;
25660 PyObject * obj0 = 0 ;
25661 PyObject * obj1 = 0 ;
25662 char *kwnames[] = {
25663 (char *) "self",(char *) "size", NULL
25664 };
25665
25666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25668 if (SWIG_arg_fail(1)) SWIG_fail;
25669 {
25670 arg2 = &temp2;
25671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25672 }
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 (arg1)->SetSize((wxSize const &)*arg2);
25676
25677 wxPyEndAllowThreads(__tstate);
25678 if (PyErr_Occurred()) SWIG_fail;
25679 }
25680 Py_INCREF(Py_None); resultobj = Py_None;
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj;
25689 wxWindow *arg1 = (wxWindow *) 0 ;
25690 int arg2 ;
25691 int arg3 ;
25692 int arg4 ;
25693 int arg5 ;
25694 int arg6 = (int) wxSIZE_AUTO ;
25695 PyObject * obj0 = 0 ;
25696 PyObject * obj1 = 0 ;
25697 PyObject * obj2 = 0 ;
25698 PyObject * obj3 = 0 ;
25699 PyObject * obj4 = 0 ;
25700 PyObject * obj5 = 0 ;
25701 char *kwnames[] = {
25702 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25703 };
25704
25705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25707 if (SWIG_arg_fail(1)) SWIG_fail;
25708 {
25709 arg2 = (int)(SWIG_As_int(obj1));
25710 if (SWIG_arg_fail(2)) SWIG_fail;
25711 }
25712 {
25713 arg3 = (int)(SWIG_As_int(obj2));
25714 if (SWIG_arg_fail(3)) SWIG_fail;
25715 }
25716 {
25717 arg4 = (int)(SWIG_As_int(obj3));
25718 if (SWIG_arg_fail(4)) SWIG_fail;
25719 }
25720 {
25721 arg5 = (int)(SWIG_As_int(obj4));
25722 if (SWIG_arg_fail(5)) SWIG_fail;
25723 }
25724 if (obj5) {
25725 {
25726 arg6 = (int)(SWIG_As_int(obj5));
25727 if (SWIG_arg_fail(6)) SWIG_fail;
25728 }
25729 }
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25733
25734 wxPyEndAllowThreads(__tstate);
25735 if (PyErr_Occurred()) SWIG_fail;
25736 }
25737 Py_INCREF(Py_None); resultobj = Py_None;
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25745 PyObject *resultobj;
25746 wxWindow *arg1 = (wxWindow *) 0 ;
25747 wxRect *arg2 = 0 ;
25748 int arg3 = (int) wxSIZE_AUTO ;
25749 wxRect temp2 ;
25750 PyObject * obj0 = 0 ;
25751 PyObject * obj1 = 0 ;
25752 PyObject * obj2 = 0 ;
25753 char *kwnames[] = {
25754 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25755 };
25756
25757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = &temp2;
25762 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25763 }
25764 if (obj2) {
25765 {
25766 arg3 = (int)(SWIG_As_int(obj2));
25767 if (SWIG_arg_fail(3)) SWIG_fail;
25768 }
25769 }
25770 {
25771 PyThreadState* __tstate = wxPyBeginAllowThreads();
25772 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25773
25774 wxPyEndAllowThreads(__tstate);
25775 if (PyErr_Occurred()) SWIG_fail;
25776 }
25777 Py_INCREF(Py_None); resultobj = Py_None;
25778 return resultobj;
25779 fail:
25780 return NULL;
25781 }
25782
25783
25784 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25785 PyObject *resultobj;
25786 wxWindow *arg1 = (wxWindow *) 0 ;
25787 int arg2 ;
25788 int arg3 ;
25789 PyObject * obj0 = 0 ;
25790 PyObject * obj1 = 0 ;
25791 PyObject * obj2 = 0 ;
25792 char *kwnames[] = {
25793 (char *) "self",(char *) "width",(char *) "height", NULL
25794 };
25795
25796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25798 if (SWIG_arg_fail(1)) SWIG_fail;
25799 {
25800 arg2 = (int)(SWIG_As_int(obj1));
25801 if (SWIG_arg_fail(2)) SWIG_fail;
25802 }
25803 {
25804 arg3 = (int)(SWIG_As_int(obj2));
25805 if (SWIG_arg_fail(3)) SWIG_fail;
25806 }
25807 {
25808 PyThreadState* __tstate = wxPyBeginAllowThreads();
25809 (arg1)->SetSize(arg2,arg3);
25810
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 Py_INCREF(Py_None); resultobj = Py_None;
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25822 PyObject *resultobj;
25823 wxWindow *arg1 = (wxWindow *) 0 ;
25824 wxPoint *arg2 = 0 ;
25825 int arg3 = (int) wxSIZE_USE_EXISTING ;
25826 wxPoint temp2 ;
25827 PyObject * obj0 = 0 ;
25828 PyObject * obj1 = 0 ;
25829 PyObject * obj2 = 0 ;
25830 char *kwnames[] = {
25831 (char *) "self",(char *) "pt",(char *) "flags", NULL
25832 };
25833
25834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25836 if (SWIG_arg_fail(1)) SWIG_fail;
25837 {
25838 arg2 = &temp2;
25839 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25840 }
25841 if (obj2) {
25842 {
25843 arg3 = (int)(SWIG_As_int(obj2));
25844 if (SWIG_arg_fail(3)) SWIG_fail;
25845 }
25846 }
25847 {
25848 PyThreadState* __tstate = wxPyBeginAllowThreads();
25849 (arg1)->Move((wxPoint const &)*arg2,arg3);
25850
25851 wxPyEndAllowThreads(__tstate);
25852 if (PyErr_Occurred()) SWIG_fail;
25853 }
25854 Py_INCREF(Py_None); resultobj = Py_None;
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25862 PyObject *resultobj;
25863 wxWindow *arg1 = (wxWindow *) 0 ;
25864 int arg2 ;
25865 int arg3 ;
25866 int arg4 = (int) wxSIZE_USE_EXISTING ;
25867 PyObject * obj0 = 0 ;
25868 PyObject * obj1 = 0 ;
25869 PyObject * obj2 = 0 ;
25870 PyObject * obj3 = 0 ;
25871 char *kwnames[] = {
25872 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25873 };
25874
25875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25877 if (SWIG_arg_fail(1)) SWIG_fail;
25878 {
25879 arg2 = (int)(SWIG_As_int(obj1));
25880 if (SWIG_arg_fail(2)) SWIG_fail;
25881 }
25882 {
25883 arg3 = (int)(SWIG_As_int(obj2));
25884 if (SWIG_arg_fail(3)) SWIG_fail;
25885 }
25886 if (obj3) {
25887 {
25888 arg4 = (int)(SWIG_As_int(obj3));
25889 if (SWIG_arg_fail(4)) SWIG_fail;
25890 }
25891 }
25892 {
25893 PyThreadState* __tstate = wxPyBeginAllowThreads();
25894 (arg1)->Move(arg2,arg3,arg4);
25895
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 Py_INCREF(Py_None); resultobj = Py_None;
25900 return resultobj;
25901 fail:
25902 return NULL;
25903 }
25904
25905
25906 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25907 PyObject *resultobj;
25908 wxWindow *arg1 = (wxWindow *) 0 ;
25909 wxSize const &arg2_defvalue = wxDefaultSize ;
25910 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25911 wxSize temp2 ;
25912 PyObject * obj0 = 0 ;
25913 PyObject * obj1 = 0 ;
25914 char *kwnames[] = {
25915 (char *) "self",(char *) "size", NULL
25916 };
25917
25918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25920 if (SWIG_arg_fail(1)) SWIG_fail;
25921 if (obj1) {
25922 {
25923 arg2 = &temp2;
25924 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25925 }
25926 }
25927 {
25928 PyThreadState* __tstate = wxPyBeginAllowThreads();
25929 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25930
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 Py_INCREF(Py_None); resultobj = Py_None;
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj;
25943 wxWindow *arg1 = (wxWindow *) 0 ;
25944 PyObject * obj0 = 0 ;
25945 char *kwnames[] = {
25946 (char *) "self", NULL
25947 };
25948
25949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25951 if (SWIG_arg_fail(1)) SWIG_fail;
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 (arg1)->Raise();
25955
25956 wxPyEndAllowThreads(__tstate);
25957 if (PyErr_Occurred()) SWIG_fail;
25958 }
25959 Py_INCREF(Py_None); resultobj = Py_None;
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25967 PyObject *resultobj;
25968 wxWindow *arg1 = (wxWindow *) 0 ;
25969 PyObject * obj0 = 0 ;
25970 char *kwnames[] = {
25971 (char *) "self", NULL
25972 };
25973
25974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25976 if (SWIG_arg_fail(1)) SWIG_fail;
25977 {
25978 PyThreadState* __tstate = wxPyBeginAllowThreads();
25979 (arg1)->Lower();
25980
25981 wxPyEndAllowThreads(__tstate);
25982 if (PyErr_Occurred()) SWIG_fail;
25983 }
25984 Py_INCREF(Py_None); resultobj = Py_None;
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj;
25993 wxWindow *arg1 = (wxWindow *) 0 ;
25994 wxSize *arg2 = 0 ;
25995 wxSize temp2 ;
25996 PyObject * obj0 = 0 ;
25997 PyObject * obj1 = 0 ;
25998 char *kwnames[] = {
25999 (char *) "self",(char *) "size", NULL
26000 };
26001
26002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26004 if (SWIG_arg_fail(1)) SWIG_fail;
26005 {
26006 arg2 = &temp2;
26007 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26008 }
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 (arg1)->SetClientSize((wxSize const &)*arg2);
26012
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 Py_INCREF(Py_None); resultobj = Py_None;
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj;
26025 wxWindow *arg1 = (wxWindow *) 0 ;
26026 int arg2 ;
26027 int arg3 ;
26028 PyObject * obj0 = 0 ;
26029 PyObject * obj1 = 0 ;
26030 PyObject * obj2 = 0 ;
26031 char *kwnames[] = {
26032 (char *) "self",(char *) "width",(char *) "height", NULL
26033 };
26034
26035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26037 if (SWIG_arg_fail(1)) SWIG_fail;
26038 {
26039 arg2 = (int)(SWIG_As_int(obj1));
26040 if (SWIG_arg_fail(2)) SWIG_fail;
26041 }
26042 {
26043 arg3 = (int)(SWIG_As_int(obj2));
26044 if (SWIG_arg_fail(3)) SWIG_fail;
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 (arg1)->SetClientSize(arg2,arg3);
26049
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 Py_INCREF(Py_None); resultobj = Py_None;
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj;
26062 wxWindow *arg1 = (wxWindow *) 0 ;
26063 wxRect *arg2 = 0 ;
26064 wxRect temp2 ;
26065 PyObject * obj0 = 0 ;
26066 PyObject * obj1 = 0 ;
26067 char *kwnames[] = {
26068 (char *) "self",(char *) "rect", NULL
26069 };
26070
26071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26073 if (SWIG_arg_fail(1)) SWIG_fail;
26074 {
26075 arg2 = &temp2;
26076 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 (arg1)->SetClientSize((wxRect const &)*arg2);
26081
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 Py_INCREF(Py_None); resultobj = Py_None;
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj;
26094 wxWindow *arg1 = (wxWindow *) 0 ;
26095 wxPoint result;
26096 PyObject * obj0 = 0 ;
26097 char *kwnames[] = {
26098 (char *) "self", NULL
26099 };
26100
26101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26103 if (SWIG_arg_fail(1)) SWIG_fail;
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 result = (arg1)->GetPosition();
26107
26108 wxPyEndAllowThreads(__tstate);
26109 if (PyErr_Occurred()) SWIG_fail;
26110 }
26111 {
26112 wxPoint * resultptr;
26113 resultptr = new wxPoint((wxPoint &)(result));
26114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26115 }
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26123 PyObject *resultobj;
26124 wxWindow *arg1 = (wxWindow *) 0 ;
26125 int *arg2 = (int *) 0 ;
26126 int *arg3 = (int *) 0 ;
26127 int temp2 ;
26128 int res2 = 0 ;
26129 int temp3 ;
26130 int res3 = 0 ;
26131 PyObject * obj0 = 0 ;
26132 char *kwnames[] = {
26133 (char *) "self", NULL
26134 };
26135
26136 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26137 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26140 if (SWIG_arg_fail(1)) SWIG_fail;
26141 {
26142 PyThreadState* __tstate = wxPyBeginAllowThreads();
26143 (arg1)->GetPosition(arg2,arg3);
26144
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 Py_INCREF(Py_None); resultobj = Py_None;
26149 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26150 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26151 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26152 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26160 PyObject *resultobj;
26161 wxWindow *arg1 = (wxWindow *) 0 ;
26162 wxSize result;
26163 PyObject * obj0 = 0 ;
26164 char *kwnames[] = {
26165 (char *) "self", NULL
26166 };
26167
26168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26170 if (SWIG_arg_fail(1)) SWIG_fail;
26171 {
26172 PyThreadState* __tstate = wxPyBeginAllowThreads();
26173 result = ((wxWindow const *)arg1)->GetSize();
26174
26175 wxPyEndAllowThreads(__tstate);
26176 if (PyErr_Occurred()) SWIG_fail;
26177 }
26178 {
26179 wxSize * resultptr;
26180 resultptr = new wxSize((wxSize &)(result));
26181 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26182 }
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26190 PyObject *resultobj;
26191 wxWindow *arg1 = (wxWindow *) 0 ;
26192 int *arg2 = (int *) 0 ;
26193 int *arg3 = (int *) 0 ;
26194 int temp2 ;
26195 int res2 = 0 ;
26196 int temp3 ;
26197 int res3 = 0 ;
26198 PyObject * obj0 = 0 ;
26199 char *kwnames[] = {
26200 (char *) "self", NULL
26201 };
26202
26203 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26204 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26207 if (SWIG_arg_fail(1)) SWIG_fail;
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26211
26212 wxPyEndAllowThreads(__tstate);
26213 if (PyErr_Occurred()) SWIG_fail;
26214 }
26215 Py_INCREF(Py_None); resultobj = Py_None;
26216 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26217 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26218 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26219 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26227 PyObject *resultobj;
26228 wxWindow *arg1 = (wxWindow *) 0 ;
26229 wxRect result;
26230 PyObject * obj0 = 0 ;
26231 char *kwnames[] = {
26232 (char *) "self", NULL
26233 };
26234
26235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26237 if (SWIG_arg_fail(1)) SWIG_fail;
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = ((wxWindow const *)arg1)->GetRect();
26241
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 {
26246 wxRect * resultptr;
26247 resultptr = new wxRect((wxRect &)(result));
26248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26249 }
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26257 PyObject *resultobj;
26258 wxWindow *arg1 = (wxWindow *) 0 ;
26259 wxSize result;
26260 PyObject * obj0 = 0 ;
26261 char *kwnames[] = {
26262 (char *) "self", NULL
26263 };
26264
26265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26267 if (SWIG_arg_fail(1)) SWIG_fail;
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 result = ((wxWindow const *)arg1)->GetClientSize();
26271
26272 wxPyEndAllowThreads(__tstate);
26273 if (PyErr_Occurred()) SWIG_fail;
26274 }
26275 {
26276 wxSize * resultptr;
26277 resultptr = new wxSize((wxSize &)(result));
26278 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26279 }
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26287 PyObject *resultobj;
26288 wxWindow *arg1 = (wxWindow *) 0 ;
26289 int *arg2 = (int *) 0 ;
26290 int *arg3 = (int *) 0 ;
26291 int temp2 ;
26292 int res2 = 0 ;
26293 int temp3 ;
26294 int res3 = 0 ;
26295 PyObject * obj0 = 0 ;
26296 char *kwnames[] = {
26297 (char *) "self", NULL
26298 };
26299
26300 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26301 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26304 if (SWIG_arg_fail(1)) SWIG_fail;
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26308
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 Py_INCREF(Py_None); resultobj = Py_None;
26313 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26314 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26315 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26316 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26317 return resultobj;
26318 fail:
26319 return NULL;
26320 }
26321
26322
26323 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj;
26325 wxWindow *arg1 = (wxWindow *) 0 ;
26326 wxPoint result;
26327 PyObject * obj0 = 0 ;
26328 char *kwnames[] = {
26329 (char *) "self", NULL
26330 };
26331
26332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26334 if (SWIG_arg_fail(1)) SWIG_fail;
26335 {
26336 PyThreadState* __tstate = wxPyBeginAllowThreads();
26337 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26338
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 {
26343 wxPoint * resultptr;
26344 resultptr = new wxPoint((wxPoint &)(result));
26345 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26346 }
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj;
26355 wxWindow *arg1 = (wxWindow *) 0 ;
26356 wxRect result;
26357 PyObject * obj0 = 0 ;
26358 char *kwnames[] = {
26359 (char *) "self", NULL
26360 };
26361
26362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26364 if (SWIG_arg_fail(1)) SWIG_fail;
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = ((wxWindow const *)arg1)->GetClientRect();
26368
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 {
26373 wxRect * resultptr;
26374 resultptr = new wxRect((wxRect &)(result));
26375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26376 }
26377 return resultobj;
26378 fail:
26379 return NULL;
26380 }
26381
26382
26383 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26384 PyObject *resultobj;
26385 wxWindow *arg1 = (wxWindow *) 0 ;
26386 wxSize result;
26387 PyObject * obj0 = 0 ;
26388 char *kwnames[] = {
26389 (char *) "self", NULL
26390 };
26391
26392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26394 if (SWIG_arg_fail(1)) SWIG_fail;
26395 {
26396 PyThreadState* __tstate = wxPyBeginAllowThreads();
26397 result = ((wxWindow const *)arg1)->GetBestSize();
26398
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 {
26403 wxSize * resultptr;
26404 resultptr = new wxSize((wxSize &)(result));
26405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26406 }
26407 return resultobj;
26408 fail:
26409 return NULL;
26410 }
26411
26412
26413 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26414 PyObject *resultobj;
26415 wxWindow *arg1 = (wxWindow *) 0 ;
26416 int *arg2 = (int *) 0 ;
26417 int *arg3 = (int *) 0 ;
26418 int temp2 ;
26419 int res2 = 0 ;
26420 int temp3 ;
26421 int res3 = 0 ;
26422 PyObject * obj0 = 0 ;
26423 char *kwnames[] = {
26424 (char *) "self", NULL
26425 };
26426
26427 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26428 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26431 if (SWIG_arg_fail(1)) SWIG_fail;
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26435
26436 wxPyEndAllowThreads(__tstate);
26437 if (PyErr_Occurred()) SWIG_fail;
26438 }
26439 Py_INCREF(Py_None); resultobj = Py_None;
26440 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26441 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26442 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26443 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26451 PyObject *resultobj;
26452 wxWindow *arg1 = (wxWindow *) 0 ;
26453 PyObject * obj0 = 0 ;
26454 char *kwnames[] = {
26455 (char *) "self", NULL
26456 };
26457
26458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26460 if (SWIG_arg_fail(1)) SWIG_fail;
26461 {
26462 PyThreadState* __tstate = wxPyBeginAllowThreads();
26463 (arg1)->InvalidateBestSize();
26464
26465 wxPyEndAllowThreads(__tstate);
26466 if (PyErr_Occurred()) SWIG_fail;
26467 }
26468 Py_INCREF(Py_None); resultobj = Py_None;
26469 return resultobj;
26470 fail:
26471 return NULL;
26472 }
26473
26474
26475 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26476 PyObject *resultobj;
26477 wxWindow *arg1 = (wxWindow *) 0 ;
26478 wxSize result;
26479 PyObject * obj0 = 0 ;
26480 char *kwnames[] = {
26481 (char *) "self", NULL
26482 };
26483
26484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26486 if (SWIG_arg_fail(1)) SWIG_fail;
26487 {
26488 PyThreadState* __tstate = wxPyBeginAllowThreads();
26489 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26490
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 {
26495 wxSize * resultptr;
26496 resultptr = new wxSize((wxSize &)(result));
26497 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26498 }
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26506 PyObject *resultobj;
26507 wxWindow *arg1 = (wxWindow *) 0 ;
26508 wxSize result;
26509 PyObject * obj0 = 0 ;
26510 char *kwnames[] = {
26511 (char *) "self", NULL
26512 };
26513
26514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26516 if (SWIG_arg_fail(1)) SWIG_fail;
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26520
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 {
26525 wxSize * resultptr;
26526 resultptr = new wxSize((wxSize &)(result));
26527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26528 }
26529 return resultobj;
26530 fail:
26531 return NULL;
26532 }
26533
26534
26535 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26536 PyObject *resultobj;
26537 wxWindow *arg1 = (wxWindow *) 0 ;
26538 int arg2 = (int) wxBOTH ;
26539 PyObject * obj0 = 0 ;
26540 PyObject * obj1 = 0 ;
26541 char *kwnames[] = {
26542 (char *) "self",(char *) "direction", NULL
26543 };
26544
26545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26547 if (SWIG_arg_fail(1)) SWIG_fail;
26548 if (obj1) {
26549 {
26550 arg2 = (int)(SWIG_As_int(obj1));
26551 if (SWIG_arg_fail(2)) SWIG_fail;
26552 }
26553 }
26554 {
26555 PyThreadState* __tstate = wxPyBeginAllowThreads();
26556 (arg1)->Center(arg2);
26557
26558 wxPyEndAllowThreads(__tstate);
26559 if (PyErr_Occurred()) SWIG_fail;
26560 }
26561 Py_INCREF(Py_None); resultobj = Py_None;
26562 return resultobj;
26563 fail:
26564 return NULL;
26565 }
26566
26567
26568 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26569 PyObject *resultobj;
26570 wxWindow *arg1 = (wxWindow *) 0 ;
26571 int arg2 = (int) wxBOTH ;
26572 PyObject * obj0 = 0 ;
26573 PyObject * obj1 = 0 ;
26574 char *kwnames[] = {
26575 (char *) "self",(char *) "dir", NULL
26576 };
26577
26578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26580 if (SWIG_arg_fail(1)) SWIG_fail;
26581 if (obj1) {
26582 {
26583 arg2 = (int)(SWIG_As_int(obj1));
26584 if (SWIG_arg_fail(2)) SWIG_fail;
26585 }
26586 }
26587 {
26588 PyThreadState* __tstate = wxPyBeginAllowThreads();
26589 (arg1)->CenterOnScreen(arg2);
26590
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 Py_INCREF(Py_None); resultobj = Py_None;
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26602 PyObject *resultobj;
26603 wxWindow *arg1 = (wxWindow *) 0 ;
26604 int arg2 = (int) wxBOTH ;
26605 PyObject * obj0 = 0 ;
26606 PyObject * obj1 = 0 ;
26607 char *kwnames[] = {
26608 (char *) "self",(char *) "dir", NULL
26609 };
26610
26611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26613 if (SWIG_arg_fail(1)) SWIG_fail;
26614 if (obj1) {
26615 {
26616 arg2 = (int)(SWIG_As_int(obj1));
26617 if (SWIG_arg_fail(2)) SWIG_fail;
26618 }
26619 }
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 (arg1)->CenterOnParent(arg2);
26623
26624 wxPyEndAllowThreads(__tstate);
26625 if (PyErr_Occurred()) SWIG_fail;
26626 }
26627 Py_INCREF(Py_None); resultobj = Py_None;
26628 return resultobj;
26629 fail:
26630 return NULL;
26631 }
26632
26633
26634 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26635 PyObject *resultobj;
26636 wxWindow *arg1 = (wxWindow *) 0 ;
26637 PyObject * obj0 = 0 ;
26638 char *kwnames[] = {
26639 (char *) "self", NULL
26640 };
26641
26642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26644 if (SWIG_arg_fail(1)) SWIG_fail;
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 (arg1)->Fit();
26648
26649 wxPyEndAllowThreads(__tstate);
26650 if (PyErr_Occurred()) SWIG_fail;
26651 }
26652 Py_INCREF(Py_None); resultobj = Py_None;
26653 return resultobj;
26654 fail:
26655 return NULL;
26656 }
26657
26658
26659 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj;
26661 wxWindow *arg1 = (wxWindow *) 0 ;
26662 PyObject * obj0 = 0 ;
26663 char *kwnames[] = {
26664 (char *) "self", NULL
26665 };
26666
26667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26669 if (SWIG_arg_fail(1)) SWIG_fail;
26670 {
26671 PyThreadState* __tstate = wxPyBeginAllowThreads();
26672 (arg1)->FitInside();
26673
26674 wxPyEndAllowThreads(__tstate);
26675 if (PyErr_Occurred()) SWIG_fail;
26676 }
26677 Py_INCREF(Py_None); resultobj = Py_None;
26678 return resultobj;
26679 fail:
26680 return NULL;
26681 }
26682
26683
26684 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj;
26686 wxWindow *arg1 = (wxWindow *) 0 ;
26687 int arg2 ;
26688 int arg3 ;
26689 int arg4 = (int) -1 ;
26690 int arg5 = (int) -1 ;
26691 int arg6 = (int) -1 ;
26692 int arg7 = (int) -1 ;
26693 PyObject * obj0 = 0 ;
26694 PyObject * obj1 = 0 ;
26695 PyObject * obj2 = 0 ;
26696 PyObject * obj3 = 0 ;
26697 PyObject * obj4 = 0 ;
26698 PyObject * obj5 = 0 ;
26699 PyObject * obj6 = 0 ;
26700 char *kwnames[] = {
26701 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26702 };
26703
26704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26706 if (SWIG_arg_fail(1)) SWIG_fail;
26707 {
26708 arg2 = (int)(SWIG_As_int(obj1));
26709 if (SWIG_arg_fail(2)) SWIG_fail;
26710 }
26711 {
26712 arg3 = (int)(SWIG_As_int(obj2));
26713 if (SWIG_arg_fail(3)) SWIG_fail;
26714 }
26715 if (obj3) {
26716 {
26717 arg4 = (int)(SWIG_As_int(obj3));
26718 if (SWIG_arg_fail(4)) SWIG_fail;
26719 }
26720 }
26721 if (obj4) {
26722 {
26723 arg5 = (int)(SWIG_As_int(obj4));
26724 if (SWIG_arg_fail(5)) SWIG_fail;
26725 }
26726 }
26727 if (obj5) {
26728 {
26729 arg6 = (int)(SWIG_As_int(obj5));
26730 if (SWIG_arg_fail(6)) SWIG_fail;
26731 }
26732 }
26733 if (obj6) {
26734 {
26735 arg7 = (int)(SWIG_As_int(obj6));
26736 if (SWIG_arg_fail(7)) SWIG_fail;
26737 }
26738 }
26739 {
26740 PyThreadState* __tstate = wxPyBeginAllowThreads();
26741 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26742
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 Py_INCREF(Py_None); resultobj = Py_None;
26747 return resultobj;
26748 fail:
26749 return NULL;
26750 }
26751
26752
26753 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26754 PyObject *resultobj;
26755 wxWindow *arg1 = (wxWindow *) 0 ;
26756 wxSize *arg2 = 0 ;
26757 wxSize const &arg3_defvalue = wxDefaultSize ;
26758 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26759 wxSize const &arg4_defvalue = wxDefaultSize ;
26760 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26761 wxSize temp2 ;
26762 wxSize temp3 ;
26763 wxSize temp4 ;
26764 PyObject * obj0 = 0 ;
26765 PyObject * obj1 = 0 ;
26766 PyObject * obj2 = 0 ;
26767 PyObject * obj3 = 0 ;
26768 char *kwnames[] = {
26769 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26770 };
26771
26772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26774 if (SWIG_arg_fail(1)) SWIG_fail;
26775 {
26776 arg2 = &temp2;
26777 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26778 }
26779 if (obj2) {
26780 {
26781 arg3 = &temp3;
26782 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26783 }
26784 }
26785 if (obj3) {
26786 {
26787 arg4 = &temp4;
26788 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26789 }
26790 }
26791 {
26792 PyThreadState* __tstate = wxPyBeginAllowThreads();
26793 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26794
26795 wxPyEndAllowThreads(__tstate);
26796 if (PyErr_Occurred()) SWIG_fail;
26797 }
26798 Py_INCREF(Py_None); resultobj = Py_None;
26799 return resultobj;
26800 fail:
26801 return NULL;
26802 }
26803
26804
26805 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26806 PyObject *resultobj;
26807 wxWindow *arg1 = (wxWindow *) 0 ;
26808 int arg2 ;
26809 int arg3 ;
26810 int arg4 = (int) -1 ;
26811 int arg5 = (int) -1 ;
26812 PyObject * obj0 = 0 ;
26813 PyObject * obj1 = 0 ;
26814 PyObject * obj2 = 0 ;
26815 PyObject * obj3 = 0 ;
26816 PyObject * obj4 = 0 ;
26817 char *kwnames[] = {
26818 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26819 };
26820
26821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26823 if (SWIG_arg_fail(1)) SWIG_fail;
26824 {
26825 arg2 = (int)(SWIG_As_int(obj1));
26826 if (SWIG_arg_fail(2)) SWIG_fail;
26827 }
26828 {
26829 arg3 = (int)(SWIG_As_int(obj2));
26830 if (SWIG_arg_fail(3)) SWIG_fail;
26831 }
26832 if (obj3) {
26833 {
26834 arg4 = (int)(SWIG_As_int(obj3));
26835 if (SWIG_arg_fail(4)) SWIG_fail;
26836 }
26837 }
26838 if (obj4) {
26839 {
26840 arg5 = (int)(SWIG_As_int(obj4));
26841 if (SWIG_arg_fail(5)) SWIG_fail;
26842 }
26843 }
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26847
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 Py_INCREF(Py_None); resultobj = Py_None;
26852 return resultobj;
26853 fail:
26854 return NULL;
26855 }
26856
26857
26858 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26859 PyObject *resultobj;
26860 wxWindow *arg1 = (wxWindow *) 0 ;
26861 wxSize *arg2 = 0 ;
26862 wxSize const &arg3_defvalue = wxDefaultSize ;
26863 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26864 wxSize temp2 ;
26865 wxSize temp3 ;
26866 PyObject * obj0 = 0 ;
26867 PyObject * obj1 = 0 ;
26868 PyObject * obj2 = 0 ;
26869 char *kwnames[] = {
26870 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26871 };
26872
26873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26875 if (SWIG_arg_fail(1)) SWIG_fail;
26876 {
26877 arg2 = &temp2;
26878 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26879 }
26880 if (obj2) {
26881 {
26882 arg3 = &temp3;
26883 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26884 }
26885 }
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26889
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 Py_INCREF(Py_None); resultobj = Py_None;
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj;
26902 wxWindow *arg1 = (wxWindow *) 0 ;
26903 wxSize result;
26904 PyObject * obj0 = 0 ;
26905 char *kwnames[] = {
26906 (char *) "self", NULL
26907 };
26908
26909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26911 if (SWIG_arg_fail(1)) SWIG_fail;
26912 {
26913 PyThreadState* __tstate = wxPyBeginAllowThreads();
26914 result = ((wxWindow const *)arg1)->GetMaxSize();
26915
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 {
26920 wxSize * resultptr;
26921 resultptr = new wxSize((wxSize &)(result));
26922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26923 }
26924 return resultobj;
26925 fail:
26926 return NULL;
26927 }
26928
26929
26930 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26931 PyObject *resultobj;
26932 wxWindow *arg1 = (wxWindow *) 0 ;
26933 wxSize result;
26934 PyObject * obj0 = 0 ;
26935 char *kwnames[] = {
26936 (char *) "self", NULL
26937 };
26938
26939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26941 if (SWIG_arg_fail(1)) SWIG_fail;
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = ((wxWindow const *)arg1)->GetMinSize();
26945
26946 wxPyEndAllowThreads(__tstate);
26947 if (PyErr_Occurred()) SWIG_fail;
26948 }
26949 {
26950 wxSize * resultptr;
26951 resultptr = new wxSize((wxSize &)(result));
26952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26953 }
26954 return resultobj;
26955 fail:
26956 return NULL;
26957 }
26958
26959
26960 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26961 PyObject *resultobj;
26962 wxWindow *arg1 = (wxWindow *) 0 ;
26963 wxSize *arg2 = 0 ;
26964 wxSize temp2 ;
26965 PyObject * obj0 = 0 ;
26966 PyObject * obj1 = 0 ;
26967 char *kwnames[] = {
26968 (char *) "self",(char *) "minSize", NULL
26969 };
26970
26971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26973 if (SWIG_arg_fail(1)) SWIG_fail;
26974 {
26975 arg2 = &temp2;
26976 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26977 }
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 (arg1)->SetMinSize((wxSize const &)*arg2);
26981
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 Py_INCREF(Py_None); resultobj = Py_None;
26986 return resultobj;
26987 fail:
26988 return NULL;
26989 }
26990
26991
26992 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj;
26994 wxWindow *arg1 = (wxWindow *) 0 ;
26995 wxSize *arg2 = 0 ;
26996 wxSize temp2 ;
26997 PyObject * obj0 = 0 ;
26998 PyObject * obj1 = 0 ;
26999 char *kwnames[] = {
27000 (char *) "self",(char *) "maxSize", NULL
27001 };
27002
27003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27005 if (SWIG_arg_fail(1)) SWIG_fail;
27006 {
27007 arg2 = &temp2;
27008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27009 }
27010 {
27011 PyThreadState* __tstate = wxPyBeginAllowThreads();
27012 (arg1)->SetMaxSize((wxSize const &)*arg2);
27013
27014 wxPyEndAllowThreads(__tstate);
27015 if (PyErr_Occurred()) SWIG_fail;
27016 }
27017 Py_INCREF(Py_None); resultobj = Py_None;
27018 return resultobj;
27019 fail:
27020 return NULL;
27021 }
27022
27023
27024 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27025 PyObject *resultobj;
27026 wxWindow *arg1 = (wxWindow *) 0 ;
27027 int result;
27028 PyObject * obj0 = 0 ;
27029 char *kwnames[] = {
27030 (char *) "self", NULL
27031 };
27032
27033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27035 if (SWIG_arg_fail(1)) SWIG_fail;
27036 {
27037 PyThreadState* __tstate = wxPyBeginAllowThreads();
27038 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27039
27040 wxPyEndAllowThreads(__tstate);
27041 if (PyErr_Occurred()) SWIG_fail;
27042 }
27043 {
27044 resultobj = SWIG_From_int((int)(result));
27045 }
27046 return resultobj;
27047 fail:
27048 return NULL;
27049 }
27050
27051
27052 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27053 PyObject *resultobj;
27054 wxWindow *arg1 = (wxWindow *) 0 ;
27055 int result;
27056 PyObject * obj0 = 0 ;
27057 char *kwnames[] = {
27058 (char *) "self", NULL
27059 };
27060
27061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27063 if (SWIG_arg_fail(1)) SWIG_fail;
27064 {
27065 PyThreadState* __tstate = wxPyBeginAllowThreads();
27066 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27067
27068 wxPyEndAllowThreads(__tstate);
27069 if (PyErr_Occurred()) SWIG_fail;
27070 }
27071 {
27072 resultobj = SWIG_From_int((int)(result));
27073 }
27074 return resultobj;
27075 fail:
27076 return NULL;
27077 }
27078
27079
27080 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27081 PyObject *resultobj;
27082 wxWindow *arg1 = (wxWindow *) 0 ;
27083 int result;
27084 PyObject * obj0 = 0 ;
27085 char *kwnames[] = {
27086 (char *) "self", NULL
27087 };
27088
27089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27091 if (SWIG_arg_fail(1)) SWIG_fail;
27092 {
27093 PyThreadState* __tstate = wxPyBeginAllowThreads();
27094 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27095
27096 wxPyEndAllowThreads(__tstate);
27097 if (PyErr_Occurred()) SWIG_fail;
27098 }
27099 {
27100 resultobj = SWIG_From_int((int)(result));
27101 }
27102 return resultobj;
27103 fail:
27104 return NULL;
27105 }
27106
27107
27108 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27109 PyObject *resultobj;
27110 wxWindow *arg1 = (wxWindow *) 0 ;
27111 int result;
27112 PyObject * obj0 = 0 ;
27113 char *kwnames[] = {
27114 (char *) "self", NULL
27115 };
27116
27117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27119 if (SWIG_arg_fail(1)) SWIG_fail;
27120 {
27121 PyThreadState* __tstate = wxPyBeginAllowThreads();
27122 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27123
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 {
27128 resultobj = SWIG_From_int((int)(result));
27129 }
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj;
27138 wxWindow *arg1 = (wxWindow *) 0 ;
27139 wxSize *arg2 = 0 ;
27140 wxSize temp2 ;
27141 PyObject * obj0 = 0 ;
27142 PyObject * obj1 = 0 ;
27143 char *kwnames[] = {
27144 (char *) "self",(char *) "size", NULL
27145 };
27146
27147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27149 if (SWIG_arg_fail(1)) SWIG_fail;
27150 {
27151 arg2 = &temp2;
27152 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27153 }
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27157
27158 wxPyEndAllowThreads(__tstate);
27159 if (PyErr_Occurred()) SWIG_fail;
27160 }
27161 Py_INCREF(Py_None); resultobj = Py_None;
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27169 PyObject *resultobj;
27170 wxWindow *arg1 = (wxWindow *) 0 ;
27171 int arg2 ;
27172 int arg3 ;
27173 PyObject * obj0 = 0 ;
27174 PyObject * obj1 = 0 ;
27175 PyObject * obj2 = 0 ;
27176 char *kwnames[] = {
27177 (char *) "self",(char *) "w",(char *) "h", NULL
27178 };
27179
27180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27182 if (SWIG_arg_fail(1)) SWIG_fail;
27183 {
27184 arg2 = (int)(SWIG_As_int(obj1));
27185 if (SWIG_arg_fail(2)) SWIG_fail;
27186 }
27187 {
27188 arg3 = (int)(SWIG_As_int(obj2));
27189 if (SWIG_arg_fail(3)) SWIG_fail;
27190 }
27191 {
27192 PyThreadState* __tstate = wxPyBeginAllowThreads();
27193 (arg1)->SetVirtualSize(arg2,arg3);
27194
27195 wxPyEndAllowThreads(__tstate);
27196 if (PyErr_Occurred()) SWIG_fail;
27197 }
27198 Py_INCREF(Py_None); resultobj = Py_None;
27199 return resultobj;
27200 fail:
27201 return NULL;
27202 }
27203
27204
27205 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27206 PyObject *resultobj;
27207 wxWindow *arg1 = (wxWindow *) 0 ;
27208 wxSize result;
27209 PyObject * obj0 = 0 ;
27210 char *kwnames[] = {
27211 (char *) "self", NULL
27212 };
27213
27214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27216 if (SWIG_arg_fail(1)) SWIG_fail;
27217 {
27218 PyThreadState* __tstate = wxPyBeginAllowThreads();
27219 result = ((wxWindow const *)arg1)->GetVirtualSize();
27220
27221 wxPyEndAllowThreads(__tstate);
27222 if (PyErr_Occurred()) SWIG_fail;
27223 }
27224 {
27225 wxSize * resultptr;
27226 resultptr = new wxSize((wxSize &)(result));
27227 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27228 }
27229 return resultobj;
27230 fail:
27231 return NULL;
27232 }
27233
27234
27235 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27236 PyObject *resultobj;
27237 wxWindow *arg1 = (wxWindow *) 0 ;
27238 int *arg2 = (int *) 0 ;
27239 int *arg3 = (int *) 0 ;
27240 int temp2 ;
27241 int res2 = 0 ;
27242 int temp3 ;
27243 int res3 = 0 ;
27244 PyObject * obj0 = 0 ;
27245 char *kwnames[] = {
27246 (char *) "self", NULL
27247 };
27248
27249 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27250 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27253 if (SWIG_arg_fail(1)) SWIG_fail;
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27257
27258 wxPyEndAllowThreads(__tstate);
27259 if (PyErr_Occurred()) SWIG_fail;
27260 }
27261 Py_INCREF(Py_None); resultobj = Py_None;
27262 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27263 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27264 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27265 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27273 PyObject *resultobj;
27274 wxWindow *arg1 = (wxWindow *) 0 ;
27275 wxSize result;
27276 PyObject * obj0 = 0 ;
27277 char *kwnames[] = {
27278 (char *) "self", NULL
27279 };
27280
27281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27283 if (SWIG_arg_fail(1)) SWIG_fail;
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27287
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 {
27292 wxSize * resultptr;
27293 resultptr = new wxSize((wxSize &)(result));
27294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27295 }
27296 return resultobj;
27297 fail:
27298 return NULL;
27299 }
27300
27301
27302 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27303 PyObject *resultobj;
27304 wxWindow *arg1 = (wxWindow *) 0 ;
27305 bool arg2 = (bool) true ;
27306 bool result;
27307 PyObject * obj0 = 0 ;
27308 PyObject * obj1 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "self",(char *) "show", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(1)) SWIG_fail;
27316 if (obj1) {
27317 {
27318 arg2 = (bool)(SWIG_As_bool(obj1));
27319 if (SWIG_arg_fail(2)) SWIG_fail;
27320 }
27321 }
27322 {
27323 PyThreadState* __tstate = wxPyBeginAllowThreads();
27324 result = (bool)(arg1)->Show(arg2);
27325
27326 wxPyEndAllowThreads(__tstate);
27327 if (PyErr_Occurred()) SWIG_fail;
27328 }
27329 {
27330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27331 }
27332 return resultobj;
27333 fail:
27334 return NULL;
27335 }
27336
27337
27338 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27339 PyObject *resultobj;
27340 wxWindow *arg1 = (wxWindow *) 0 ;
27341 bool result;
27342 PyObject * obj0 = 0 ;
27343 char *kwnames[] = {
27344 (char *) "self", NULL
27345 };
27346
27347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27349 if (SWIG_arg_fail(1)) SWIG_fail;
27350 {
27351 PyThreadState* __tstate = wxPyBeginAllowThreads();
27352 result = (bool)(arg1)->Hide();
27353
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 {
27358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27359 }
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27367 PyObject *resultobj;
27368 wxWindow *arg1 = (wxWindow *) 0 ;
27369 bool arg2 = (bool) true ;
27370 bool result;
27371 PyObject * obj0 = 0 ;
27372 PyObject * obj1 = 0 ;
27373 char *kwnames[] = {
27374 (char *) "self",(char *) "enable", NULL
27375 };
27376
27377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27379 if (SWIG_arg_fail(1)) SWIG_fail;
27380 if (obj1) {
27381 {
27382 arg2 = (bool)(SWIG_As_bool(obj1));
27383 if (SWIG_arg_fail(2)) SWIG_fail;
27384 }
27385 }
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (bool)(arg1)->Enable(arg2);
27389
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 {
27394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27395 }
27396 return resultobj;
27397 fail:
27398 return NULL;
27399 }
27400
27401
27402 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27403 PyObject *resultobj;
27404 wxWindow *arg1 = (wxWindow *) 0 ;
27405 bool result;
27406 PyObject * obj0 = 0 ;
27407 char *kwnames[] = {
27408 (char *) "self", NULL
27409 };
27410
27411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27413 if (SWIG_arg_fail(1)) SWIG_fail;
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (bool)(arg1)->Disable();
27417
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 {
27422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxWindow *arg1 = (wxWindow *) 0 ;
27433 bool result;
27434 PyObject * obj0 = 0 ;
27435 char *kwnames[] = {
27436 (char *) "self", NULL
27437 };
27438
27439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27441 if (SWIG_arg_fail(1)) SWIG_fail;
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (bool)((wxWindow const *)arg1)->IsShown();
27445
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 {
27450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27451 }
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27459 PyObject *resultobj;
27460 wxWindow *arg1 = (wxWindow *) 0 ;
27461 bool result;
27462 PyObject * obj0 = 0 ;
27463 char *kwnames[] = {
27464 (char *) "self", NULL
27465 };
27466
27467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27469 if (SWIG_arg_fail(1)) SWIG_fail;
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27473
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 {
27478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27479 }
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27487 PyObject *resultobj;
27488 wxWindow *arg1 = (wxWindow *) 0 ;
27489 long arg2 ;
27490 PyObject * obj0 = 0 ;
27491 PyObject * obj1 = 0 ;
27492 char *kwnames[] = {
27493 (char *) "self",(char *) "style", NULL
27494 };
27495
27496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27498 if (SWIG_arg_fail(1)) SWIG_fail;
27499 {
27500 arg2 = (long)(SWIG_As_long(obj1));
27501 if (SWIG_arg_fail(2)) SWIG_fail;
27502 }
27503 {
27504 PyThreadState* __tstate = wxPyBeginAllowThreads();
27505 (arg1)->SetWindowStyleFlag(arg2);
27506
27507 wxPyEndAllowThreads(__tstate);
27508 if (PyErr_Occurred()) SWIG_fail;
27509 }
27510 Py_INCREF(Py_None); resultobj = Py_None;
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27518 PyObject *resultobj;
27519 wxWindow *arg1 = (wxWindow *) 0 ;
27520 long result;
27521 PyObject * obj0 = 0 ;
27522 char *kwnames[] = {
27523 (char *) "self", NULL
27524 };
27525
27526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27528 if (SWIG_arg_fail(1)) SWIG_fail;
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27532
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 {
27537 resultobj = SWIG_From_long((long)(result));
27538 }
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27546 PyObject *resultobj;
27547 wxWindow *arg1 = (wxWindow *) 0 ;
27548 int arg2 ;
27549 bool result;
27550 PyObject * obj0 = 0 ;
27551 PyObject * obj1 = 0 ;
27552 char *kwnames[] = {
27553 (char *) "self",(char *) "flag", NULL
27554 };
27555
27556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27558 if (SWIG_arg_fail(1)) SWIG_fail;
27559 {
27560 arg2 = (int)(SWIG_As_int(obj1));
27561 if (SWIG_arg_fail(2)) SWIG_fail;
27562 }
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27566
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 {
27571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27572 }
27573 return resultobj;
27574 fail:
27575 return NULL;
27576 }
27577
27578
27579 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27580 PyObject *resultobj;
27581 wxWindow *arg1 = (wxWindow *) 0 ;
27582 bool result;
27583 PyObject * obj0 = 0 ;
27584 char *kwnames[] = {
27585 (char *) "self", NULL
27586 };
27587
27588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27590 if (SWIG_arg_fail(1)) SWIG_fail;
27591 {
27592 PyThreadState* __tstate = wxPyBeginAllowThreads();
27593 result = (bool)((wxWindow const *)arg1)->IsRetained();
27594
27595 wxPyEndAllowThreads(__tstate);
27596 if (PyErr_Occurred()) SWIG_fail;
27597 }
27598 {
27599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27600 }
27601 return resultobj;
27602 fail:
27603 return NULL;
27604 }
27605
27606
27607 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27608 PyObject *resultobj;
27609 wxWindow *arg1 = (wxWindow *) 0 ;
27610 long arg2 ;
27611 PyObject * obj0 = 0 ;
27612 PyObject * obj1 = 0 ;
27613 char *kwnames[] = {
27614 (char *) "self",(char *) "exStyle", NULL
27615 };
27616
27617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27619 if (SWIG_arg_fail(1)) SWIG_fail;
27620 {
27621 arg2 = (long)(SWIG_As_long(obj1));
27622 if (SWIG_arg_fail(2)) SWIG_fail;
27623 }
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 (arg1)->SetExtraStyle(arg2);
27627
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 Py_INCREF(Py_None); resultobj = Py_None;
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj;
27640 wxWindow *arg1 = (wxWindow *) 0 ;
27641 long result;
27642 PyObject * obj0 = 0 ;
27643 char *kwnames[] = {
27644 (char *) "self", NULL
27645 };
27646
27647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27649 if (SWIG_arg_fail(1)) SWIG_fail;
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27653
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 {
27658 resultobj = SWIG_From_long((long)(result));
27659 }
27660 return resultobj;
27661 fail:
27662 return NULL;
27663 }
27664
27665
27666 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj;
27668 wxWindow *arg1 = (wxWindow *) 0 ;
27669 bool arg2 = (bool) true ;
27670 PyObject * obj0 = 0 ;
27671 PyObject * obj1 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "self",(char *) "modal", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27678 if (SWIG_arg_fail(1)) SWIG_fail;
27679 if (obj1) {
27680 {
27681 arg2 = (bool)(SWIG_As_bool(obj1));
27682 if (SWIG_arg_fail(2)) SWIG_fail;
27683 }
27684 }
27685 {
27686 PyThreadState* __tstate = wxPyBeginAllowThreads();
27687 (arg1)->MakeModal(arg2);
27688
27689 wxPyEndAllowThreads(__tstate);
27690 if (PyErr_Occurred()) SWIG_fail;
27691 }
27692 Py_INCREF(Py_None); resultobj = Py_None;
27693 return resultobj;
27694 fail:
27695 return NULL;
27696 }
27697
27698
27699 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27700 PyObject *resultobj;
27701 wxWindow *arg1 = (wxWindow *) 0 ;
27702 bool arg2 ;
27703 PyObject * obj0 = 0 ;
27704 PyObject * obj1 = 0 ;
27705 char *kwnames[] = {
27706 (char *) "self",(char *) "enableTheme", NULL
27707 };
27708
27709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27711 if (SWIG_arg_fail(1)) SWIG_fail;
27712 {
27713 arg2 = (bool)(SWIG_As_bool(obj1));
27714 if (SWIG_arg_fail(2)) SWIG_fail;
27715 }
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 (arg1)->SetThemeEnabled(arg2);
27719
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 Py_INCREF(Py_None); resultobj = Py_None;
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27731 PyObject *resultobj;
27732 wxWindow *arg1 = (wxWindow *) 0 ;
27733 bool result;
27734 PyObject * obj0 = 0 ;
27735 char *kwnames[] = {
27736 (char *) "self", NULL
27737 };
27738
27739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27741 if (SWIG_arg_fail(1)) SWIG_fail;
27742 {
27743 PyThreadState* __tstate = wxPyBeginAllowThreads();
27744 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27745
27746 wxPyEndAllowThreads(__tstate);
27747 if (PyErr_Occurred()) SWIG_fail;
27748 }
27749 {
27750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27751 }
27752 return resultobj;
27753 fail:
27754 return NULL;
27755 }
27756
27757
27758 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27759 PyObject *resultobj;
27760 wxWindow *arg1 = (wxWindow *) 0 ;
27761 PyObject * obj0 = 0 ;
27762 char *kwnames[] = {
27763 (char *) "self", NULL
27764 };
27765
27766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27768 if (SWIG_arg_fail(1)) SWIG_fail;
27769 {
27770 PyThreadState* __tstate = wxPyBeginAllowThreads();
27771 (arg1)->SetFocus();
27772
27773 wxPyEndAllowThreads(__tstate);
27774 if (PyErr_Occurred()) SWIG_fail;
27775 }
27776 Py_INCREF(Py_None); resultobj = Py_None;
27777 return resultobj;
27778 fail:
27779 return NULL;
27780 }
27781
27782
27783 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27784 PyObject *resultobj;
27785 wxWindow *arg1 = (wxWindow *) 0 ;
27786 PyObject * obj0 = 0 ;
27787 char *kwnames[] = {
27788 (char *) "self", NULL
27789 };
27790
27791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27793 if (SWIG_arg_fail(1)) SWIG_fail;
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 (arg1)->SetFocusFromKbd();
27797
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 Py_INCREF(Py_None); resultobj = Py_None;
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27809 PyObject *resultobj;
27810 wxWindow *result;
27811 char *kwnames[] = {
27812 NULL
27813 };
27814
27815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27816 {
27817 if (!wxPyCheckForApp()) SWIG_fail;
27818 PyThreadState* __tstate = wxPyBeginAllowThreads();
27819 result = (wxWindow *)wxWindow::FindFocus();
27820
27821 wxPyEndAllowThreads(__tstate);
27822 if (PyErr_Occurred()) SWIG_fail;
27823 }
27824 {
27825 resultobj = wxPyMake_wxObject(result, 0);
27826 }
27827 return resultobj;
27828 fail:
27829 return NULL;
27830 }
27831
27832
27833 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27834 PyObject *resultobj;
27835 wxWindow *arg1 = (wxWindow *) 0 ;
27836 bool result;
27837 PyObject * obj0 = 0 ;
27838 char *kwnames[] = {
27839 (char *) "self", NULL
27840 };
27841
27842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27844 if (SWIG_arg_fail(1)) SWIG_fail;
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27848
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 {
27853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27854 }
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27862 PyObject *resultobj;
27863 wxWindow *arg1 = (wxWindow *) 0 ;
27864 bool result;
27865 PyObject * obj0 = 0 ;
27866 char *kwnames[] = {
27867 (char *) "self", NULL
27868 };
27869
27870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 {
27881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27882 }
27883 return resultobj;
27884 fail:
27885 return NULL;
27886 }
27887
27888
27889 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27890 PyObject *resultobj;
27891 wxWindow *arg1 = (wxWindow *) 0 ;
27892 wxWindow *result;
27893 PyObject * obj0 = 0 ;
27894 char *kwnames[] = {
27895 (char *) "self", NULL
27896 };
27897
27898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27900 if (SWIG_arg_fail(1)) SWIG_fail;
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27904
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 {
27909 resultobj = wxPyMake_wxObject(result, 0);
27910 }
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27918 PyObject *resultobj;
27919 wxWindow *arg1 = (wxWindow *) 0 ;
27920 wxWindow *arg2 = (wxWindow *) 0 ;
27921 wxWindow *result;
27922 PyObject * obj0 = 0 ;
27923 PyObject * obj1 = 0 ;
27924 char *kwnames[] = {
27925 (char *) "self",(char *) "child", NULL
27926 };
27927
27928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27930 if (SWIG_arg_fail(1)) SWIG_fail;
27931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27932 if (SWIG_arg_fail(2)) SWIG_fail;
27933 {
27934 PyThreadState* __tstate = wxPyBeginAllowThreads();
27935 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27936
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 {
27941 resultobj = wxPyMake_wxObject(result, 0);
27942 }
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxWindow *arg1 = (wxWindow *) 0 ;
27952 wxWindow *arg2 = (wxWindow *) 0 ;
27953 PyObject * obj0 = 0 ;
27954 PyObject * obj1 = 0 ;
27955 char *kwnames[] = {
27956 (char *) "self",(char *) "win", NULL
27957 };
27958
27959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27961 if (SWIG_arg_fail(1)) SWIG_fail;
27962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27963 if (SWIG_arg_fail(2)) SWIG_fail;
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 (arg1)->SetTmpDefaultItem(arg2);
27967
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 Py_INCREF(Py_None); resultobj = Py_None;
27972 return resultobj;
27973 fail:
27974 return NULL;
27975 }
27976
27977
27978 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27979 PyObject *resultobj;
27980 wxWindow *arg1 = (wxWindow *) 0 ;
27981 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27982 bool result;
27983 PyObject * obj0 = 0 ;
27984 PyObject * obj1 = 0 ;
27985 char *kwnames[] = {
27986 (char *) "self",(char *) "flags", NULL
27987 };
27988
27989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27991 if (SWIG_arg_fail(1)) SWIG_fail;
27992 if (obj1) {
27993 {
27994 arg2 = (int)(SWIG_As_int(obj1));
27995 if (SWIG_arg_fail(2)) SWIG_fail;
27996 }
27997 }
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 result = (bool)(arg1)->Navigate(arg2);
28001
28002 wxPyEndAllowThreads(__tstate);
28003 if (PyErr_Occurred()) SWIG_fail;
28004 }
28005 {
28006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28007 }
28008 return resultobj;
28009 fail:
28010 return NULL;
28011 }
28012
28013
28014 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28015 PyObject *resultobj;
28016 wxWindow *arg1 = (wxWindow *) 0 ;
28017 wxWindow *arg2 = (wxWindow *) 0 ;
28018 PyObject * obj0 = 0 ;
28019 PyObject * obj1 = 0 ;
28020 char *kwnames[] = {
28021 (char *) "self",(char *) "win", NULL
28022 };
28023
28024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28026 if (SWIG_arg_fail(1)) SWIG_fail;
28027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28028 if (SWIG_arg_fail(2)) SWIG_fail;
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 (arg1)->MoveAfterInTabOrder(arg2);
28032
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 Py_INCREF(Py_None); resultobj = Py_None;
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj;
28045 wxWindow *arg1 = (wxWindow *) 0 ;
28046 wxWindow *arg2 = (wxWindow *) 0 ;
28047 PyObject * obj0 = 0 ;
28048 PyObject * obj1 = 0 ;
28049 char *kwnames[] = {
28050 (char *) "self",(char *) "win", NULL
28051 };
28052
28053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28055 if (SWIG_arg_fail(1)) SWIG_fail;
28056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28057 if (SWIG_arg_fail(2)) SWIG_fail;
28058 {
28059 PyThreadState* __tstate = wxPyBeginAllowThreads();
28060 (arg1)->MoveBeforeInTabOrder(arg2);
28061
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 Py_INCREF(Py_None); resultobj = Py_None;
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj;
28074 wxWindow *arg1 = (wxWindow *) 0 ;
28075 PyObject *result;
28076 PyObject * obj0 = 0 ;
28077 char *kwnames[] = {
28078 (char *) "self", NULL
28079 };
28080
28081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28083 if (SWIG_arg_fail(1)) SWIG_fail;
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 result = (PyObject *)wxWindow_GetChildren(arg1);
28087
28088 wxPyEndAllowThreads(__tstate);
28089 if (PyErr_Occurred()) SWIG_fail;
28090 }
28091 resultobj = result;
28092 return resultobj;
28093 fail:
28094 return NULL;
28095 }
28096
28097
28098 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28099 PyObject *resultobj;
28100 wxWindow *arg1 = (wxWindow *) 0 ;
28101 wxWindow *result;
28102 PyObject * obj0 = 0 ;
28103 char *kwnames[] = {
28104 (char *) "self", NULL
28105 };
28106
28107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28109 if (SWIG_arg_fail(1)) SWIG_fail;
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28113
28114 wxPyEndAllowThreads(__tstate);
28115 if (PyErr_Occurred()) SWIG_fail;
28116 }
28117 {
28118 resultobj = wxPyMake_wxObject(result, 0);
28119 }
28120 return resultobj;
28121 fail:
28122 return NULL;
28123 }
28124
28125
28126 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28127 PyObject *resultobj;
28128 wxWindow *arg1 = (wxWindow *) 0 ;
28129 wxWindow *result;
28130 PyObject * obj0 = 0 ;
28131 char *kwnames[] = {
28132 (char *) "self", NULL
28133 };
28134
28135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28137 if (SWIG_arg_fail(1)) SWIG_fail;
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28141
28142 wxPyEndAllowThreads(__tstate);
28143 if (PyErr_Occurred()) SWIG_fail;
28144 }
28145 {
28146 resultobj = wxPyMake_wxObject(result, 0);
28147 }
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj;
28156 wxWindow *arg1 = (wxWindow *) 0 ;
28157 bool result;
28158 PyObject * obj0 = 0 ;
28159 char *kwnames[] = {
28160 (char *) "self", NULL
28161 };
28162
28163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28165 if (SWIG_arg_fail(1)) SWIG_fail;
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28169
28170 wxPyEndAllowThreads(__tstate);
28171 if (PyErr_Occurred()) SWIG_fail;
28172 }
28173 {
28174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28175 }
28176 return resultobj;
28177 fail:
28178 return NULL;
28179 }
28180
28181
28182 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28183 PyObject *resultobj;
28184 wxWindow *arg1 = (wxWindow *) 0 ;
28185 wxWindow *arg2 = (wxWindow *) 0 ;
28186 bool result;
28187 PyObject * obj0 = 0 ;
28188 PyObject * obj1 = 0 ;
28189 char *kwnames[] = {
28190 (char *) "self",(char *) "newParent", NULL
28191 };
28192
28193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28195 if (SWIG_arg_fail(1)) SWIG_fail;
28196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28197 if (SWIG_arg_fail(2)) SWIG_fail;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (bool)(arg1)->Reparent(arg2);
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 {
28206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28207 }
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj;
28216 wxWindow *arg1 = (wxWindow *) 0 ;
28217 wxWindow *arg2 = (wxWindow *) 0 ;
28218 PyObject * obj0 = 0 ;
28219 PyObject * obj1 = 0 ;
28220 char *kwnames[] = {
28221 (char *) "self",(char *) "child", NULL
28222 };
28223
28224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28226 if (SWIG_arg_fail(1)) SWIG_fail;
28227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28228 if (SWIG_arg_fail(2)) SWIG_fail;
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 (arg1)->AddChild(arg2);
28232
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 Py_INCREF(Py_None); resultobj = Py_None;
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28244 PyObject *resultobj;
28245 wxWindow *arg1 = (wxWindow *) 0 ;
28246 wxWindow *arg2 = (wxWindow *) 0 ;
28247 PyObject * obj0 = 0 ;
28248 PyObject * obj1 = 0 ;
28249 char *kwnames[] = {
28250 (char *) "self",(char *) "child", NULL
28251 };
28252
28253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28255 if (SWIG_arg_fail(1)) SWIG_fail;
28256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28257 if (SWIG_arg_fail(2)) SWIG_fail;
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 (arg1)->RemoveChild(arg2);
28261
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 Py_INCREF(Py_None); resultobj = Py_None;
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj;
28274 wxWindow *arg1 = (wxWindow *) 0 ;
28275 long arg2 ;
28276 wxWindow *result;
28277 PyObject * obj0 = 0 ;
28278 PyObject * obj1 = 0 ;
28279 char *kwnames[] = {
28280 (char *) "self",(char *) "winid", NULL
28281 };
28282
28283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28285 if (SWIG_arg_fail(1)) SWIG_fail;
28286 {
28287 arg2 = (long)(SWIG_As_long(obj1));
28288 if (SWIG_arg_fail(2)) SWIG_fail;
28289 }
28290 {
28291 PyThreadState* __tstate = wxPyBeginAllowThreads();
28292 result = (wxWindow *)(arg1)->FindWindow(arg2);
28293
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 {
28298 resultobj = wxPyMake_wxObject(result, 0);
28299 }
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28307 PyObject *resultobj;
28308 wxWindow *arg1 = (wxWindow *) 0 ;
28309 wxString *arg2 = 0 ;
28310 wxWindow *result;
28311 bool temp2 = false ;
28312 PyObject * obj0 = 0 ;
28313 PyObject * obj1 = 0 ;
28314 char *kwnames[] = {
28315 (char *) "self",(char *) "name", NULL
28316 };
28317
28318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28320 if (SWIG_arg_fail(1)) SWIG_fail;
28321 {
28322 arg2 = wxString_in_helper(obj1);
28323 if (arg2 == NULL) SWIG_fail;
28324 temp2 = true;
28325 }
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28329
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 {
28334 resultobj = wxPyMake_wxObject(result, 0);
28335 }
28336 {
28337 if (temp2)
28338 delete arg2;
28339 }
28340 return resultobj;
28341 fail:
28342 {
28343 if (temp2)
28344 delete arg2;
28345 }
28346 return NULL;
28347 }
28348
28349
28350 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj;
28352 wxWindow *arg1 = (wxWindow *) 0 ;
28353 wxEvtHandler *result;
28354 PyObject * obj0 = 0 ;
28355 char *kwnames[] = {
28356 (char *) "self", NULL
28357 };
28358
28359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28361 if (SWIG_arg_fail(1)) SWIG_fail;
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 {
28370 resultobj = wxPyMake_wxObject(result, 0);
28371 }
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj;
28380 wxWindow *arg1 = (wxWindow *) 0 ;
28381 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28382 PyObject * obj0 = 0 ;
28383 PyObject * obj1 = 0 ;
28384 char *kwnames[] = {
28385 (char *) "self",(char *) "handler", NULL
28386 };
28387
28388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28390 if (SWIG_arg_fail(1)) SWIG_fail;
28391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28392 if (SWIG_arg_fail(2)) SWIG_fail;
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 (arg1)->SetEventHandler(arg2);
28396
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 Py_INCREF(Py_None); resultobj = Py_None;
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28408 PyObject *resultobj;
28409 wxWindow *arg1 = (wxWindow *) 0 ;
28410 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28411 PyObject * obj0 = 0 ;
28412 PyObject * obj1 = 0 ;
28413 char *kwnames[] = {
28414 (char *) "self",(char *) "handler", NULL
28415 };
28416
28417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28419 if (SWIG_arg_fail(1)) SWIG_fail;
28420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28421 if (SWIG_arg_fail(2)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 (arg1)->PushEventHandler(arg2);
28425
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 Py_INCREF(Py_None); resultobj = Py_None;
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28437 PyObject *resultobj;
28438 wxWindow *arg1 = (wxWindow *) 0 ;
28439 bool arg2 = (bool) false ;
28440 wxEvtHandler *result;
28441 PyObject * obj0 = 0 ;
28442 PyObject * obj1 = 0 ;
28443 char *kwnames[] = {
28444 (char *) "self",(char *) "deleteHandler", NULL
28445 };
28446
28447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28449 if (SWIG_arg_fail(1)) SWIG_fail;
28450 if (obj1) {
28451 {
28452 arg2 = (bool)(SWIG_As_bool(obj1));
28453 if (SWIG_arg_fail(2)) SWIG_fail;
28454 }
28455 }
28456 {
28457 PyThreadState* __tstate = wxPyBeginAllowThreads();
28458 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28459
28460 wxPyEndAllowThreads(__tstate);
28461 if (PyErr_Occurred()) SWIG_fail;
28462 }
28463 {
28464 resultobj = wxPyMake_wxObject(result, 0);
28465 }
28466 return resultobj;
28467 fail:
28468 return NULL;
28469 }
28470
28471
28472 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28473 PyObject *resultobj;
28474 wxWindow *arg1 = (wxWindow *) 0 ;
28475 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28476 bool result;
28477 PyObject * obj0 = 0 ;
28478 PyObject * obj1 = 0 ;
28479 char *kwnames[] = {
28480 (char *) "self",(char *) "handler", NULL
28481 };
28482
28483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28485 if (SWIG_arg_fail(1)) SWIG_fail;
28486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28487 if (SWIG_arg_fail(2)) SWIG_fail;
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 result = (bool)(arg1)->RemoveEventHandler(arg2);
28491
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj;
28506 wxWindow *arg1 = (wxWindow *) 0 ;
28507 wxValidator *arg2 = 0 ;
28508 PyObject * obj0 = 0 ;
28509 PyObject * obj1 = 0 ;
28510 char *kwnames[] = {
28511 (char *) "self",(char *) "validator", NULL
28512 };
28513
28514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28516 if (SWIG_arg_fail(1)) SWIG_fail;
28517 {
28518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28519 if (SWIG_arg_fail(2)) SWIG_fail;
28520 if (arg2 == NULL) {
28521 SWIG_null_ref("wxValidator");
28522 }
28523 if (SWIG_arg_fail(2)) SWIG_fail;
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 (arg1)->SetValidator((wxValidator const &)*arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 Py_INCREF(Py_None); resultobj = Py_None;
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj;
28541 wxWindow *arg1 = (wxWindow *) 0 ;
28542 wxValidator *result;
28543 PyObject * obj0 = 0 ;
28544 char *kwnames[] = {
28545 (char *) "self", NULL
28546 };
28547
28548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28550 if (SWIG_arg_fail(1)) SWIG_fail;
28551 {
28552 PyThreadState* __tstate = wxPyBeginAllowThreads();
28553 result = (wxValidator *)(arg1)->GetValidator();
28554
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 {
28559 resultobj = wxPyMake_wxObject(result, 0);
28560 }
28561 return resultobj;
28562 fail:
28563 return NULL;
28564 }
28565
28566
28567 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28568 PyObject *resultobj;
28569 wxWindow *arg1 = (wxWindow *) 0 ;
28570 bool result;
28571 PyObject * obj0 = 0 ;
28572 char *kwnames[] = {
28573 (char *) "self", NULL
28574 };
28575
28576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28578 if (SWIG_arg_fail(1)) SWIG_fail;
28579 {
28580 PyThreadState* __tstate = wxPyBeginAllowThreads();
28581 result = (bool)(arg1)->Validate();
28582
28583 wxPyEndAllowThreads(__tstate);
28584 if (PyErr_Occurred()) SWIG_fail;
28585 }
28586 {
28587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28588 }
28589 return resultobj;
28590 fail:
28591 return NULL;
28592 }
28593
28594
28595 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28596 PyObject *resultobj;
28597 wxWindow *arg1 = (wxWindow *) 0 ;
28598 bool result;
28599 PyObject * obj0 = 0 ;
28600 char *kwnames[] = {
28601 (char *) "self", NULL
28602 };
28603
28604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28606 if (SWIG_arg_fail(1)) SWIG_fail;
28607 {
28608 PyThreadState* __tstate = wxPyBeginAllowThreads();
28609 result = (bool)(arg1)->TransferDataToWindow();
28610
28611 wxPyEndAllowThreads(__tstate);
28612 if (PyErr_Occurred()) SWIG_fail;
28613 }
28614 {
28615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28616 }
28617 return resultobj;
28618 fail:
28619 return NULL;
28620 }
28621
28622
28623 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28624 PyObject *resultobj;
28625 wxWindow *arg1 = (wxWindow *) 0 ;
28626 bool result;
28627 PyObject * obj0 = 0 ;
28628 char *kwnames[] = {
28629 (char *) "self", NULL
28630 };
28631
28632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28634 if (SWIG_arg_fail(1)) SWIG_fail;
28635 {
28636 PyThreadState* __tstate = wxPyBeginAllowThreads();
28637 result = (bool)(arg1)->TransferDataFromWindow();
28638
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 {
28643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28644 }
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28652 PyObject *resultobj;
28653 wxWindow *arg1 = (wxWindow *) 0 ;
28654 PyObject * obj0 = 0 ;
28655 char *kwnames[] = {
28656 (char *) "self", NULL
28657 };
28658
28659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28661 if (SWIG_arg_fail(1)) SWIG_fail;
28662 {
28663 PyThreadState* __tstate = wxPyBeginAllowThreads();
28664 (arg1)->InitDialog();
28665
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 Py_INCREF(Py_None); resultobj = Py_None;
28670 return resultobj;
28671 fail:
28672 return NULL;
28673 }
28674
28675
28676 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28677 PyObject *resultobj;
28678 wxWindow *arg1 = (wxWindow *) 0 ;
28679 wxAcceleratorTable *arg2 = 0 ;
28680 PyObject * obj0 = 0 ;
28681 PyObject * obj1 = 0 ;
28682 char *kwnames[] = {
28683 (char *) "self",(char *) "accel", NULL
28684 };
28685
28686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28688 if (SWIG_arg_fail(1)) SWIG_fail;
28689 {
28690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28691 if (SWIG_arg_fail(2)) SWIG_fail;
28692 if (arg2 == NULL) {
28693 SWIG_null_ref("wxAcceleratorTable");
28694 }
28695 if (SWIG_arg_fail(2)) SWIG_fail;
28696 }
28697 {
28698 PyThreadState* __tstate = wxPyBeginAllowThreads();
28699 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28700
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 Py_INCREF(Py_None); resultobj = Py_None;
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28712 PyObject *resultobj;
28713 wxWindow *arg1 = (wxWindow *) 0 ;
28714 wxAcceleratorTable *result;
28715 PyObject * obj0 = 0 ;
28716 char *kwnames[] = {
28717 (char *) "self", NULL
28718 };
28719
28720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28722 if (SWIG_arg_fail(1)) SWIG_fail;
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28726
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28738 PyObject *resultobj;
28739 wxWindow *arg1 = (wxWindow *) 0 ;
28740 int arg2 ;
28741 int arg3 ;
28742 int arg4 ;
28743 bool result;
28744 PyObject * obj0 = 0 ;
28745 PyObject * obj1 = 0 ;
28746 PyObject * obj2 = 0 ;
28747 PyObject * obj3 = 0 ;
28748 char *kwnames[] = {
28749 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28750 };
28751
28752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28754 if (SWIG_arg_fail(1)) SWIG_fail;
28755 {
28756 arg2 = (int)(SWIG_As_int(obj1));
28757 if (SWIG_arg_fail(2)) SWIG_fail;
28758 }
28759 {
28760 arg3 = (int)(SWIG_As_int(obj2));
28761 if (SWIG_arg_fail(3)) SWIG_fail;
28762 }
28763 {
28764 arg4 = (int)(SWIG_As_int(obj3));
28765 if (SWIG_arg_fail(4)) SWIG_fail;
28766 }
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28770
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 {
28775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28776 }
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28784 PyObject *resultobj;
28785 wxWindow *arg1 = (wxWindow *) 0 ;
28786 int arg2 ;
28787 bool result;
28788 PyObject * obj0 = 0 ;
28789 PyObject * obj1 = 0 ;
28790 char *kwnames[] = {
28791 (char *) "self",(char *) "hotkeyId", NULL
28792 };
28793
28794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28796 if (SWIG_arg_fail(1)) SWIG_fail;
28797 {
28798 arg2 = (int)(SWIG_As_int(obj1));
28799 if (SWIG_arg_fail(2)) SWIG_fail;
28800 }
28801 {
28802 PyThreadState* __tstate = wxPyBeginAllowThreads();
28803 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28804
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 {
28809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28810 }
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28818 PyObject *resultobj;
28819 wxWindow *arg1 = (wxWindow *) 0 ;
28820 wxPoint *arg2 = 0 ;
28821 wxPoint result;
28822 wxPoint temp2 ;
28823 PyObject * obj0 = 0 ;
28824 PyObject * obj1 = 0 ;
28825 char *kwnames[] = {
28826 (char *) "self",(char *) "pt", NULL
28827 };
28828
28829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28831 if (SWIG_arg_fail(1)) SWIG_fail;
28832 {
28833 arg2 = &temp2;
28834 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28835 }
28836 {
28837 PyThreadState* __tstate = wxPyBeginAllowThreads();
28838 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28839
28840 wxPyEndAllowThreads(__tstate);
28841 if (PyErr_Occurred()) SWIG_fail;
28842 }
28843 {
28844 wxPoint * resultptr;
28845 resultptr = new wxPoint((wxPoint &)(result));
28846 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28847 }
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28855 PyObject *resultobj;
28856 wxWindow *arg1 = (wxWindow *) 0 ;
28857 wxSize *arg2 = 0 ;
28858 wxSize result;
28859 wxSize temp2 ;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char *kwnames[] = {
28863 (char *) "self",(char *) "sz", NULL
28864 };
28865
28866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28868 if (SWIG_arg_fail(1)) SWIG_fail;
28869 {
28870 arg2 = &temp2;
28871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28872 }
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 wxSize * resultptr;
28882 resultptr = new wxSize((wxSize &)(result));
28883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28884 }
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28892 PyObject *resultobj;
28893 wxWindow *arg1 = (wxWindow *) 0 ;
28894 wxPoint *arg2 = 0 ;
28895 wxPoint result;
28896 wxPoint temp2 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 char *kwnames[] = {
28900 (char *) "self",(char *) "pt", NULL
28901 };
28902
28903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28905 if (SWIG_arg_fail(1)) SWIG_fail;
28906 {
28907 arg2 = &temp2;
28908 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28909 }
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28913
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 {
28918 wxPoint * resultptr;
28919 resultptr = new wxPoint((wxPoint &)(result));
28920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28921 }
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28929 PyObject *resultobj;
28930 wxWindow *arg1 = (wxWindow *) 0 ;
28931 wxSize *arg2 = 0 ;
28932 wxSize result;
28933 wxSize temp2 ;
28934 PyObject * obj0 = 0 ;
28935 PyObject * obj1 = 0 ;
28936 char *kwnames[] = {
28937 (char *) "self",(char *) "sz", NULL
28938 };
28939
28940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28942 if (SWIG_arg_fail(1)) SWIG_fail;
28943 {
28944 arg2 = &temp2;
28945 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28946 }
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28950
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 {
28955 wxSize * resultptr;
28956 resultptr = new wxSize((wxSize &)(result));
28957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28958 }
28959 return resultobj;
28960 fail:
28961 return NULL;
28962 }
28963
28964
28965 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj;
28967 wxWindow *arg1 = (wxWindow *) 0 ;
28968 wxPoint *arg2 = 0 ;
28969 wxPoint result;
28970 wxPoint temp2 ;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 char *kwnames[] = {
28974 (char *) "self",(char *) "pt", NULL
28975 };
28976
28977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28979 if (SWIG_arg_fail(1)) SWIG_fail;
28980 {
28981 arg2 = &temp2;
28982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28983 }
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28987
28988 wxPyEndAllowThreads(__tstate);
28989 if (PyErr_Occurred()) SWIG_fail;
28990 }
28991 {
28992 wxPoint * resultptr;
28993 resultptr = new wxPoint((wxPoint &)(result));
28994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28995 }
28996 return resultobj;
28997 fail:
28998 return NULL;
28999 }
29000
29001
29002 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29003 PyObject *resultobj;
29004 wxWindow *arg1 = (wxWindow *) 0 ;
29005 wxSize *arg2 = 0 ;
29006 wxSize result;
29007 wxSize temp2 ;
29008 PyObject * obj0 = 0 ;
29009 PyObject * obj1 = 0 ;
29010 char *kwnames[] = {
29011 (char *) "self",(char *) "sz", NULL
29012 };
29013
29014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29016 if (SWIG_arg_fail(1)) SWIG_fail;
29017 {
29018 arg2 = &temp2;
29019 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29020 }
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29024
29025 wxPyEndAllowThreads(__tstate);
29026 if (PyErr_Occurred()) SWIG_fail;
29027 }
29028 {
29029 wxSize * resultptr;
29030 resultptr = new wxSize((wxSize &)(result));
29031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29032 }
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29040 PyObject *resultobj;
29041 wxWindow *arg1 = (wxWindow *) 0 ;
29042 int arg2 ;
29043 int arg3 ;
29044 PyObject * obj0 = 0 ;
29045 PyObject * obj1 = 0 ;
29046 PyObject * obj2 = 0 ;
29047 char *kwnames[] = {
29048 (char *) "self",(char *) "x",(char *) "y", NULL
29049 };
29050
29051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29053 if (SWIG_arg_fail(1)) SWIG_fail;
29054 {
29055 arg2 = (int)(SWIG_As_int(obj1));
29056 if (SWIG_arg_fail(2)) SWIG_fail;
29057 }
29058 {
29059 arg3 = (int)(SWIG_As_int(obj2));
29060 if (SWIG_arg_fail(3)) SWIG_fail;
29061 }
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 (arg1)->WarpPointer(arg2,arg3);
29065
29066 wxPyEndAllowThreads(__tstate);
29067 if (PyErr_Occurred()) SWIG_fail;
29068 }
29069 Py_INCREF(Py_None); resultobj = Py_None;
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj;
29078 wxWindow *arg1 = (wxWindow *) 0 ;
29079 PyObject * obj0 = 0 ;
29080 char *kwnames[] = {
29081 (char *) "self", NULL
29082 };
29083
29084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29086 if (SWIG_arg_fail(1)) SWIG_fail;
29087 {
29088 PyThreadState* __tstate = wxPyBeginAllowThreads();
29089 (arg1)->CaptureMouse();
29090
29091 wxPyEndAllowThreads(__tstate);
29092 if (PyErr_Occurred()) SWIG_fail;
29093 }
29094 Py_INCREF(Py_None); resultobj = Py_None;
29095 return resultobj;
29096 fail:
29097 return NULL;
29098 }
29099
29100
29101 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29102 PyObject *resultobj;
29103 wxWindow *arg1 = (wxWindow *) 0 ;
29104 PyObject * obj0 = 0 ;
29105 char *kwnames[] = {
29106 (char *) "self", NULL
29107 };
29108
29109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29111 if (SWIG_arg_fail(1)) SWIG_fail;
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 (arg1)->ReleaseMouse();
29115
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 Py_INCREF(Py_None); resultobj = Py_None;
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj;
29128 wxWindow *result;
29129 char *kwnames[] = {
29130 NULL
29131 };
29132
29133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29134 {
29135 if (!wxPyCheckForApp()) SWIG_fail;
29136 PyThreadState* __tstate = wxPyBeginAllowThreads();
29137 result = (wxWindow *)wxWindow::GetCapture();
29138
29139 wxPyEndAllowThreads(__tstate);
29140 if (PyErr_Occurred()) SWIG_fail;
29141 }
29142 {
29143 resultobj = wxPyMake_wxObject(result, 0);
29144 }
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29152 PyObject *resultobj;
29153 wxWindow *arg1 = (wxWindow *) 0 ;
29154 bool result;
29155 PyObject * obj0 = 0 ;
29156 char *kwnames[] = {
29157 (char *) "self", NULL
29158 };
29159
29160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29162 if (SWIG_arg_fail(1)) SWIG_fail;
29163 {
29164 PyThreadState* __tstate = wxPyBeginAllowThreads();
29165 result = (bool)((wxWindow const *)arg1)->HasCapture();
29166
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 {
29171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29172 }
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29180 PyObject *resultobj;
29181 wxWindow *arg1 = (wxWindow *) 0 ;
29182 bool arg2 = (bool) true ;
29183 wxRect *arg3 = (wxRect *) NULL ;
29184 PyObject * obj0 = 0 ;
29185 PyObject * obj1 = 0 ;
29186 PyObject * obj2 = 0 ;
29187 char *kwnames[] = {
29188 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29189 };
29190
29191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29193 if (SWIG_arg_fail(1)) SWIG_fail;
29194 if (obj1) {
29195 {
29196 arg2 = (bool)(SWIG_As_bool(obj1));
29197 if (SWIG_arg_fail(2)) SWIG_fail;
29198 }
29199 }
29200 if (obj2) {
29201 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29202 if (SWIG_arg_fail(3)) SWIG_fail;
29203 }
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29207
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 Py_INCREF(Py_None); resultobj = Py_None;
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29219 PyObject *resultobj;
29220 wxWindow *arg1 = (wxWindow *) 0 ;
29221 wxRect *arg2 = 0 ;
29222 bool arg3 = (bool) true ;
29223 wxRect temp2 ;
29224 PyObject * obj0 = 0 ;
29225 PyObject * obj1 = 0 ;
29226 PyObject * obj2 = 0 ;
29227 char *kwnames[] = {
29228 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29229 };
29230
29231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29233 if (SWIG_arg_fail(1)) SWIG_fail;
29234 {
29235 arg2 = &temp2;
29236 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29237 }
29238 if (obj2) {
29239 {
29240 arg3 = (bool)(SWIG_As_bool(obj2));
29241 if (SWIG_arg_fail(3)) SWIG_fail;
29242 }
29243 }
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29247
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 Py_INCREF(Py_None); resultobj = Py_None;
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29259 PyObject *resultobj;
29260 wxWindow *arg1 = (wxWindow *) 0 ;
29261 PyObject * obj0 = 0 ;
29262 char *kwnames[] = {
29263 (char *) "self", NULL
29264 };
29265
29266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29268 if (SWIG_arg_fail(1)) SWIG_fail;
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 (arg1)->Update();
29272
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 Py_INCREF(Py_None); resultobj = Py_None;
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj;
29285 wxWindow *arg1 = (wxWindow *) 0 ;
29286 PyObject * obj0 = 0 ;
29287 char *kwnames[] = {
29288 (char *) "self", NULL
29289 };
29290
29291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29293 if (SWIG_arg_fail(1)) SWIG_fail;
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 (arg1)->ClearBackground();
29297
29298 wxPyEndAllowThreads(__tstate);
29299 if (PyErr_Occurred()) SWIG_fail;
29300 }
29301 Py_INCREF(Py_None); resultobj = Py_None;
29302 return resultobj;
29303 fail:
29304 return NULL;
29305 }
29306
29307
29308 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29309 PyObject *resultobj;
29310 wxWindow *arg1 = (wxWindow *) 0 ;
29311 PyObject * obj0 = 0 ;
29312 char *kwnames[] = {
29313 (char *) "self", NULL
29314 };
29315
29316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29318 if (SWIG_arg_fail(1)) SWIG_fail;
29319 {
29320 PyThreadState* __tstate = wxPyBeginAllowThreads();
29321 (arg1)->Freeze();
29322
29323 wxPyEndAllowThreads(__tstate);
29324 if (PyErr_Occurred()) SWIG_fail;
29325 }
29326 Py_INCREF(Py_None); resultobj = Py_None;
29327 return resultobj;
29328 fail:
29329 return NULL;
29330 }
29331
29332
29333 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29334 PyObject *resultobj;
29335 wxWindow *arg1 = (wxWindow *) 0 ;
29336 PyObject * obj0 = 0 ;
29337 char *kwnames[] = {
29338 (char *) "self", NULL
29339 };
29340
29341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29343 if (SWIG_arg_fail(1)) SWIG_fail;
29344 {
29345 PyThreadState* __tstate = wxPyBeginAllowThreads();
29346 (arg1)->Thaw();
29347
29348 wxPyEndAllowThreads(__tstate);
29349 if (PyErr_Occurred()) SWIG_fail;
29350 }
29351 Py_INCREF(Py_None); resultobj = Py_None;
29352 return resultobj;
29353 fail:
29354 return NULL;
29355 }
29356
29357
29358 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29359 PyObject *resultobj;
29360 wxWindow *arg1 = (wxWindow *) 0 ;
29361 wxDC *arg2 = 0 ;
29362 PyObject * obj0 = 0 ;
29363 PyObject * obj1 = 0 ;
29364 char *kwnames[] = {
29365 (char *) "self",(char *) "dc", NULL
29366 };
29367
29368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29373 if (SWIG_arg_fail(2)) SWIG_fail;
29374 if (arg2 == NULL) {
29375 SWIG_null_ref("wxDC");
29376 }
29377 if (SWIG_arg_fail(2)) SWIG_fail;
29378 }
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 (arg1)->PrepareDC(*arg2);
29382
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 Py_INCREF(Py_None); resultobj = Py_None;
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj;
29395 wxWindow *arg1 = (wxWindow *) 0 ;
29396 wxRegion *result;
29397 PyObject * obj0 = 0 ;
29398 char *kwnames[] = {
29399 (char *) "self", NULL
29400 };
29401
29402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29404 if (SWIG_arg_fail(1)) SWIG_fail;
29405 {
29406 PyThreadState* __tstate = wxPyBeginAllowThreads();
29407 {
29408 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29409 result = (wxRegion *) &_result_ref;
29410 }
29411
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29423 PyObject *resultobj;
29424 wxWindow *arg1 = (wxWindow *) 0 ;
29425 wxRect result;
29426 PyObject * obj0 = 0 ;
29427 char *kwnames[] = {
29428 (char *) "self", NULL
29429 };
29430
29431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29433 if (SWIG_arg_fail(1)) SWIG_fail;
29434 {
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29437
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 {
29442 wxRect * resultptr;
29443 resultptr = new wxRect((wxRect &)(result));
29444 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29445 }
29446 return resultobj;
29447 fail:
29448 return NULL;
29449 }
29450
29451
29452 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29453 PyObject *resultobj;
29454 wxWindow *arg1 = (wxWindow *) 0 ;
29455 int arg2 ;
29456 int arg3 ;
29457 int arg4 = (int) 1 ;
29458 int arg5 = (int) 1 ;
29459 bool result;
29460 PyObject * obj0 = 0 ;
29461 PyObject * obj1 = 0 ;
29462 PyObject * obj2 = 0 ;
29463 PyObject * obj3 = 0 ;
29464 PyObject * obj4 = 0 ;
29465 char *kwnames[] = {
29466 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29467 };
29468
29469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29471 if (SWIG_arg_fail(1)) SWIG_fail;
29472 {
29473 arg2 = (int)(SWIG_As_int(obj1));
29474 if (SWIG_arg_fail(2)) SWIG_fail;
29475 }
29476 {
29477 arg3 = (int)(SWIG_As_int(obj2));
29478 if (SWIG_arg_fail(3)) SWIG_fail;
29479 }
29480 if (obj3) {
29481 {
29482 arg4 = (int)(SWIG_As_int(obj3));
29483 if (SWIG_arg_fail(4)) SWIG_fail;
29484 }
29485 }
29486 if (obj4) {
29487 {
29488 arg5 = (int)(SWIG_As_int(obj4));
29489 if (SWIG_arg_fail(5)) SWIG_fail;
29490 }
29491 }
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29495
29496 wxPyEndAllowThreads(__tstate);
29497 if (PyErr_Occurred()) SWIG_fail;
29498 }
29499 {
29500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29501 }
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29509 PyObject *resultobj;
29510 wxWindow *arg1 = (wxWindow *) 0 ;
29511 wxPoint *arg2 = 0 ;
29512 bool result;
29513 wxPoint temp2 ;
29514 PyObject * obj0 = 0 ;
29515 PyObject * obj1 = 0 ;
29516 char *kwnames[] = {
29517 (char *) "self",(char *) "pt", NULL
29518 };
29519
29520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29522 if (SWIG_arg_fail(1)) SWIG_fail;
29523 {
29524 arg2 = &temp2;
29525 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29526 }
29527 {
29528 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29530
29531 wxPyEndAllowThreads(__tstate);
29532 if (PyErr_Occurred()) SWIG_fail;
29533 }
29534 {
29535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29536 }
29537 return resultobj;
29538 fail:
29539 return NULL;
29540 }
29541
29542
29543 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29544 PyObject *resultobj;
29545 wxWindow *arg1 = (wxWindow *) 0 ;
29546 wxRect *arg2 = 0 ;
29547 bool result;
29548 wxRect temp2 ;
29549 PyObject * obj0 = 0 ;
29550 PyObject * obj1 = 0 ;
29551 char *kwnames[] = {
29552 (char *) "self",(char *) "rect", NULL
29553 };
29554
29555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29557 if (SWIG_arg_fail(1)) SWIG_fail;
29558 {
29559 arg2 = &temp2;
29560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29561 }
29562 {
29563 PyThreadState* __tstate = wxPyBeginAllowThreads();
29564 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29565
29566 wxPyEndAllowThreads(__tstate);
29567 if (PyErr_Occurred()) SWIG_fail;
29568 }
29569 {
29570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29571 }
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29579 PyObject *resultobj;
29580 wxWindow *arg1 = (wxWindow *) 0 ;
29581 wxVisualAttributes result;
29582 PyObject * obj0 = 0 ;
29583 char *kwnames[] = {
29584 (char *) "self", NULL
29585 };
29586
29587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29589 if (SWIG_arg_fail(1)) SWIG_fail;
29590 {
29591 PyThreadState* __tstate = wxPyBeginAllowThreads();
29592 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29593
29594 wxPyEndAllowThreads(__tstate);
29595 if (PyErr_Occurred()) SWIG_fail;
29596 }
29597 {
29598 wxVisualAttributes * resultptr;
29599 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29601 }
29602 return resultobj;
29603 fail:
29604 return NULL;
29605 }
29606
29607
29608 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29609 PyObject *resultobj;
29610 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29611 wxVisualAttributes result;
29612 PyObject * obj0 = 0 ;
29613 char *kwnames[] = {
29614 (char *) "variant", NULL
29615 };
29616
29617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29618 if (obj0) {
29619 {
29620 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29621 if (SWIG_arg_fail(1)) SWIG_fail;
29622 }
29623 }
29624 {
29625 if (!wxPyCheckForApp()) SWIG_fail;
29626 PyThreadState* __tstate = wxPyBeginAllowThreads();
29627 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29628
29629 wxPyEndAllowThreads(__tstate);
29630 if (PyErr_Occurred()) SWIG_fail;
29631 }
29632 {
29633 wxVisualAttributes * resultptr;
29634 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29636 }
29637 return resultobj;
29638 fail:
29639 return NULL;
29640 }
29641
29642
29643 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29644 PyObject *resultobj;
29645 wxWindow *arg1 = (wxWindow *) 0 ;
29646 wxColour *arg2 = 0 ;
29647 bool result;
29648 wxColour temp2 ;
29649 PyObject * obj0 = 0 ;
29650 PyObject * obj1 = 0 ;
29651 char *kwnames[] = {
29652 (char *) "self",(char *) "colour", NULL
29653 };
29654
29655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 {
29659 arg2 = &temp2;
29660 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29661 }
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29665
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 {
29670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29671 }
29672 return resultobj;
29673 fail:
29674 return NULL;
29675 }
29676
29677
29678 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29679 PyObject *resultobj;
29680 wxWindow *arg1 = (wxWindow *) 0 ;
29681 wxColour *arg2 = 0 ;
29682 wxColour temp2 ;
29683 PyObject * obj0 = 0 ;
29684 PyObject * obj1 = 0 ;
29685 char *kwnames[] = {
29686 (char *) "self",(char *) "colour", NULL
29687 };
29688
29689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29691 if (SWIG_arg_fail(1)) SWIG_fail;
29692 {
29693 arg2 = &temp2;
29694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29695 }
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29699
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 Py_INCREF(Py_None); resultobj = Py_None;
29704 return resultobj;
29705 fail:
29706 return NULL;
29707 }
29708
29709
29710 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29711 PyObject *resultobj;
29712 wxWindow *arg1 = (wxWindow *) 0 ;
29713 wxColour *arg2 = 0 ;
29714 bool result;
29715 wxColour temp2 ;
29716 PyObject * obj0 = 0 ;
29717 PyObject * obj1 = 0 ;
29718 char *kwnames[] = {
29719 (char *) "self",(char *) "colour", NULL
29720 };
29721
29722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29724 if (SWIG_arg_fail(1)) SWIG_fail;
29725 {
29726 arg2 = &temp2;
29727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29728 }
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29732
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 {
29737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29738 }
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29746 PyObject *resultobj;
29747 wxWindow *arg1 = (wxWindow *) 0 ;
29748 wxColour *arg2 = 0 ;
29749 wxColour temp2 ;
29750 PyObject * obj0 = 0 ;
29751 PyObject * obj1 = 0 ;
29752 char *kwnames[] = {
29753 (char *) "self",(char *) "colour", NULL
29754 };
29755
29756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29758 if (SWIG_arg_fail(1)) SWIG_fail;
29759 {
29760 arg2 = &temp2;
29761 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29762 }
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29766
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 Py_INCREF(Py_None); resultobj = Py_None;
29771 return resultobj;
29772 fail:
29773 return NULL;
29774 }
29775
29776
29777 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29778 PyObject *resultobj;
29779 wxWindow *arg1 = (wxWindow *) 0 ;
29780 wxColour result;
29781 PyObject * obj0 = 0 ;
29782 char *kwnames[] = {
29783 (char *) "self", NULL
29784 };
29785
29786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29788 if (SWIG_arg_fail(1)) SWIG_fail;
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29792
29793 wxPyEndAllowThreads(__tstate);
29794 if (PyErr_Occurred()) SWIG_fail;
29795 }
29796 {
29797 wxColour * resultptr;
29798 resultptr = new wxColour((wxColour &)(result));
29799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29800 }
29801 return resultobj;
29802 fail:
29803 return NULL;
29804 }
29805
29806
29807 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29808 PyObject *resultobj;
29809 wxWindow *arg1 = (wxWindow *) 0 ;
29810 wxColour result;
29811 PyObject * obj0 = 0 ;
29812 char *kwnames[] = {
29813 (char *) "self", NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29818 if (SWIG_arg_fail(1)) SWIG_fail;
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 result = ((wxWindow const *)arg1)->GetForegroundColour();
29822
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 {
29827 wxColour * resultptr;
29828 resultptr = new wxColour((wxColour &)(result));
29829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29830 }
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29838 PyObject *resultobj;
29839 wxWindow *arg1 = (wxWindow *) 0 ;
29840 bool result;
29841 PyObject * obj0 = 0 ;
29842 char *kwnames[] = {
29843 (char *) "self", NULL
29844 };
29845
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 {
29857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29858 }
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29866 PyObject *resultobj;
29867 wxWindow *arg1 = (wxWindow *) 0 ;
29868 bool result;
29869 PyObject * obj0 = 0 ;
29870 char *kwnames[] = {
29871 (char *) "self", NULL
29872 };
29873
29874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29876 if (SWIG_arg_fail(1)) SWIG_fail;
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29880
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 {
29885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29886 }
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj;
29895 wxWindow *arg1 = (wxWindow *) 0 ;
29896 wxBackgroundStyle arg2 ;
29897 bool result;
29898 PyObject * obj0 = 0 ;
29899 PyObject * obj1 = 0 ;
29900 char *kwnames[] = {
29901 (char *) "self",(char *) "style", NULL
29902 };
29903
29904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29906 if (SWIG_arg_fail(1)) SWIG_fail;
29907 {
29908 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29909 if (SWIG_arg_fail(2)) SWIG_fail;
29910 }
29911 {
29912 PyThreadState* __tstate = wxPyBeginAllowThreads();
29913 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29914
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 {
29919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29920 }
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj;
29929 wxWindow *arg1 = (wxWindow *) 0 ;
29930 wxBackgroundStyle result;
29931 PyObject * obj0 = 0 ;
29932 char *kwnames[] = {
29933 (char *) "self", NULL
29934 };
29935
29936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29938 if (SWIG_arg_fail(1)) SWIG_fail;
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29942
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 resultobj = SWIG_From_int((result));
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj;
29955 wxWindow *arg1 = (wxWindow *) 0 ;
29956 bool result;
29957 PyObject * obj0 = 0 ;
29958 char *kwnames[] = {
29959 (char *) "self", NULL
29960 };
29961
29962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 result = (bool)(arg1)->HasTransparentBackground();
29968
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 {
29973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29974 }
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29982 PyObject *resultobj;
29983 wxWindow *arg1 = (wxWindow *) 0 ;
29984 wxCursor *arg2 = 0 ;
29985 bool result;
29986 PyObject * obj0 = 0 ;
29987 PyObject * obj1 = 0 ;
29988 char *kwnames[] = {
29989 (char *) "self",(char *) "cursor", NULL
29990 };
29991
29992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29994 if (SWIG_arg_fail(1)) SWIG_fail;
29995 {
29996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29997 if (SWIG_arg_fail(2)) SWIG_fail;
29998 if (arg2 == NULL) {
29999 SWIG_null_ref("wxCursor");
30000 }
30001 if (SWIG_arg_fail(2)) SWIG_fail;
30002 }
30003 {
30004 PyThreadState* __tstate = wxPyBeginAllowThreads();
30005 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30006
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 {
30011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30012 }
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj;
30021 wxWindow *arg1 = (wxWindow *) 0 ;
30022 wxCursor result;
30023 PyObject * obj0 = 0 ;
30024 char *kwnames[] = {
30025 (char *) "self", NULL
30026 };
30027
30028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30030 if (SWIG_arg_fail(1)) SWIG_fail;
30031 {
30032 PyThreadState* __tstate = wxPyBeginAllowThreads();
30033 result = (arg1)->GetCursor();
30034
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 {
30039 wxCursor * resultptr;
30040 resultptr = new wxCursor((wxCursor &)(result));
30041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30042 }
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30050 PyObject *resultobj;
30051 wxWindow *arg1 = (wxWindow *) 0 ;
30052 wxFont *arg2 = 0 ;
30053 bool result;
30054 PyObject * obj0 = 0 ;
30055 PyObject * obj1 = 0 ;
30056 char *kwnames[] = {
30057 (char *) "self",(char *) "font", NULL
30058 };
30059
30060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30062 if (SWIG_arg_fail(1)) SWIG_fail;
30063 {
30064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30065 if (SWIG_arg_fail(2)) SWIG_fail;
30066 if (arg2 == NULL) {
30067 SWIG_null_ref("wxFont");
30068 }
30069 if (SWIG_arg_fail(2)) SWIG_fail;
30070 }
30071 {
30072 PyThreadState* __tstate = wxPyBeginAllowThreads();
30073 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30074
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 {
30079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30080 }
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30088 PyObject *resultobj;
30089 wxWindow *arg1 = (wxWindow *) 0 ;
30090 wxFont *arg2 = 0 ;
30091 PyObject * obj0 = 0 ;
30092 PyObject * obj1 = 0 ;
30093 char *kwnames[] = {
30094 (char *) "self",(char *) "font", NULL
30095 };
30096
30097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30099 if (SWIG_arg_fail(1)) SWIG_fail;
30100 {
30101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30102 if (SWIG_arg_fail(2)) SWIG_fail;
30103 if (arg2 == NULL) {
30104 SWIG_null_ref("wxFont");
30105 }
30106 if (SWIG_arg_fail(2)) SWIG_fail;
30107 }
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 (arg1)->SetOwnFont((wxFont const &)*arg2);
30111
30112 wxPyEndAllowThreads(__tstate);
30113 if (PyErr_Occurred()) SWIG_fail;
30114 }
30115 Py_INCREF(Py_None); resultobj = Py_None;
30116 return resultobj;
30117 fail:
30118 return NULL;
30119 }
30120
30121
30122 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30123 PyObject *resultobj;
30124 wxWindow *arg1 = (wxWindow *) 0 ;
30125 wxFont result;
30126 PyObject * obj0 = 0 ;
30127 char *kwnames[] = {
30128 (char *) "self", NULL
30129 };
30130
30131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30133 if (SWIG_arg_fail(1)) SWIG_fail;
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 result = (arg1)->GetFont();
30137
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 {
30142 wxFont * resultptr;
30143 resultptr = new wxFont((wxFont &)(result));
30144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30145 }
30146 return resultobj;
30147 fail:
30148 return NULL;
30149 }
30150
30151
30152 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30153 PyObject *resultobj;
30154 wxWindow *arg1 = (wxWindow *) 0 ;
30155 wxCaret *arg2 = (wxCaret *) 0 ;
30156 PyObject * obj0 = 0 ;
30157 PyObject * obj1 = 0 ;
30158 char *kwnames[] = {
30159 (char *) "self",(char *) "caret", NULL
30160 };
30161
30162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30164 if (SWIG_arg_fail(1)) SWIG_fail;
30165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30166 if (SWIG_arg_fail(2)) SWIG_fail;
30167 {
30168 PyThreadState* __tstate = wxPyBeginAllowThreads();
30169 (arg1)->SetCaret(arg2);
30170
30171 wxPyEndAllowThreads(__tstate);
30172 if (PyErr_Occurred()) SWIG_fail;
30173 }
30174 Py_INCREF(Py_None); resultobj = Py_None;
30175 return resultobj;
30176 fail:
30177 return NULL;
30178 }
30179
30180
30181 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30182 PyObject *resultobj;
30183 wxWindow *arg1 = (wxWindow *) 0 ;
30184 wxCaret *result;
30185 PyObject * obj0 = 0 ;
30186 char *kwnames[] = {
30187 (char *) "self", NULL
30188 };
30189
30190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30192 if (SWIG_arg_fail(1)) SWIG_fail;
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30196
30197 wxPyEndAllowThreads(__tstate);
30198 if (PyErr_Occurred()) SWIG_fail;
30199 }
30200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj;
30209 wxWindow *arg1 = (wxWindow *) 0 ;
30210 int result;
30211 PyObject * obj0 = 0 ;
30212 char *kwnames[] = {
30213 (char *) "self", NULL
30214 };
30215
30216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30218 if (SWIG_arg_fail(1)) SWIG_fail;
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30222
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 {
30227 resultobj = SWIG_From_int((int)(result));
30228 }
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj;
30237 wxWindow *arg1 = (wxWindow *) 0 ;
30238 int result;
30239 PyObject * obj0 = 0 ;
30240 char *kwnames[] = {
30241 (char *) "self", NULL
30242 };
30243
30244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) 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 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30250
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 {
30255 resultobj = SWIG_From_int((int)(result));
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj;
30265 wxWindow *arg1 = (wxWindow *) 0 ;
30266 wxString *arg2 = 0 ;
30267 int *arg3 = (int *) 0 ;
30268 int *arg4 = (int *) 0 ;
30269 bool temp2 = false ;
30270 int temp3 ;
30271 int res3 = 0 ;
30272 int temp4 ;
30273 int res4 = 0 ;
30274 PyObject * obj0 = 0 ;
30275 PyObject * obj1 = 0 ;
30276 char *kwnames[] = {
30277 (char *) "self",(char *) "string", NULL
30278 };
30279
30280 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30281 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) 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 {
30286 arg2 = wxString_in_helper(obj1);
30287 if (arg2 == NULL) SWIG_fail;
30288 temp2 = true;
30289 }
30290 {
30291 PyThreadState* __tstate = wxPyBeginAllowThreads();
30292 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30293
30294 wxPyEndAllowThreads(__tstate);
30295 if (PyErr_Occurred()) SWIG_fail;
30296 }
30297 Py_INCREF(Py_None); resultobj = Py_None;
30298 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30299 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30300 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30301 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30302 {
30303 if (temp2)
30304 delete arg2;
30305 }
30306 return resultobj;
30307 fail:
30308 {
30309 if (temp2)
30310 delete arg2;
30311 }
30312 return NULL;
30313 }
30314
30315
30316 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30317 PyObject *resultobj;
30318 wxWindow *arg1 = (wxWindow *) 0 ;
30319 wxString *arg2 = 0 ;
30320 int *arg3 = (int *) 0 ;
30321 int *arg4 = (int *) 0 ;
30322 int *arg5 = (int *) 0 ;
30323 int *arg6 = (int *) 0 ;
30324 wxFont *arg7 = (wxFont *) NULL ;
30325 bool temp2 = false ;
30326 int temp3 ;
30327 int res3 = 0 ;
30328 int temp4 ;
30329 int res4 = 0 ;
30330 int temp5 ;
30331 int res5 = 0 ;
30332 int temp6 ;
30333 int res6 = 0 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 PyObject * obj2 = 0 ;
30337 char *kwnames[] = {
30338 (char *) "self",(char *) "string",(char *) "font", NULL
30339 };
30340
30341 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30342 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30343 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30344 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30347 if (SWIG_arg_fail(1)) SWIG_fail;
30348 {
30349 arg2 = wxString_in_helper(obj1);
30350 if (arg2 == NULL) SWIG_fail;
30351 temp2 = true;
30352 }
30353 if (obj2) {
30354 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30355 if (SWIG_arg_fail(7)) SWIG_fail;
30356 }
30357 {
30358 PyThreadState* __tstate = wxPyBeginAllowThreads();
30359 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30360
30361 wxPyEndAllowThreads(__tstate);
30362 if (PyErr_Occurred()) SWIG_fail;
30363 }
30364 Py_INCREF(Py_None); resultobj = Py_None;
30365 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30366 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30367 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30368 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30369 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30370 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30371 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30372 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30373 {
30374 if (temp2)
30375 delete arg2;
30376 }
30377 return resultobj;
30378 fail:
30379 {
30380 if (temp2)
30381 delete arg2;
30382 }
30383 return NULL;
30384 }
30385
30386
30387 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30388 PyObject *resultobj;
30389 wxWindow *arg1 = (wxWindow *) 0 ;
30390 int *arg2 = (int *) 0 ;
30391 int *arg3 = (int *) 0 ;
30392 int temp2 ;
30393 int res2 = 0 ;
30394 int temp3 ;
30395 int res3 = 0 ;
30396 PyObject * obj0 = 0 ;
30397 PyObject * obj1 = 0 ;
30398 PyObject * obj2 = 0 ;
30399 char *kwnames[] = {
30400 (char *) "self",(char *) "x",(char *) "y", NULL
30401 };
30402
30403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30405 if (SWIG_arg_fail(1)) SWIG_fail;
30406 {
30407 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30408 temp2 = SWIG_As_int(obj1);
30409 if (SWIG_arg_fail(2)) SWIG_fail;
30410 arg2 = &temp2;
30411 res2 = SWIG_NEWOBJ;
30412 }
30413 }
30414 {
30415 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30416 temp3 = SWIG_As_int(obj2);
30417 if (SWIG_arg_fail(3)) SWIG_fail;
30418 arg3 = &temp3;
30419 res3 = SWIG_NEWOBJ;
30420 }
30421 }
30422 {
30423 PyThreadState* __tstate = wxPyBeginAllowThreads();
30424 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30425
30426 wxPyEndAllowThreads(__tstate);
30427 if (PyErr_Occurred()) SWIG_fail;
30428 }
30429 Py_INCREF(Py_None); resultobj = Py_None;
30430 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30431 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30432 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30433 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 int *arg2 = (int *) 0 ;
30444 int *arg3 = (int *) 0 ;
30445 int temp2 ;
30446 int res2 = 0 ;
30447 int temp3 ;
30448 int res3 = 0 ;
30449 PyObject * obj0 = 0 ;
30450 PyObject * obj1 = 0 ;
30451 PyObject * obj2 = 0 ;
30452 char *kwnames[] = {
30453 (char *) "self",(char *) "x",(char *) "y", NULL
30454 };
30455
30456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30458 if (SWIG_arg_fail(1)) SWIG_fail;
30459 {
30460 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30461 temp2 = SWIG_As_int(obj1);
30462 if (SWIG_arg_fail(2)) SWIG_fail;
30463 arg2 = &temp2;
30464 res2 = SWIG_NEWOBJ;
30465 }
30466 }
30467 {
30468 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30469 temp3 = SWIG_As_int(obj2);
30470 if (SWIG_arg_fail(3)) SWIG_fail;
30471 arg3 = &temp3;
30472 res3 = SWIG_NEWOBJ;
30473 }
30474 }
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30478
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 Py_INCREF(Py_None); resultobj = Py_None;
30483 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30484 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30485 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30486 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30494 PyObject *resultobj;
30495 wxWindow *arg1 = (wxWindow *) 0 ;
30496 wxPoint *arg2 = 0 ;
30497 wxPoint result;
30498 wxPoint temp2 ;
30499 PyObject * obj0 = 0 ;
30500 PyObject * obj1 = 0 ;
30501 char *kwnames[] = {
30502 (char *) "self",(char *) "pt", NULL
30503 };
30504
30505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30507 if (SWIG_arg_fail(1)) SWIG_fail;
30508 {
30509 arg2 = &temp2;
30510 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30511 }
30512 {
30513 PyThreadState* __tstate = wxPyBeginAllowThreads();
30514 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30515
30516 wxPyEndAllowThreads(__tstate);
30517 if (PyErr_Occurred()) SWIG_fail;
30518 }
30519 {
30520 wxPoint * resultptr;
30521 resultptr = new wxPoint((wxPoint &)(result));
30522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30523 }
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30531 PyObject *resultobj;
30532 wxWindow *arg1 = (wxWindow *) 0 ;
30533 wxPoint *arg2 = 0 ;
30534 wxPoint result;
30535 wxPoint temp2 ;
30536 PyObject * obj0 = 0 ;
30537 PyObject * obj1 = 0 ;
30538 char *kwnames[] = {
30539 (char *) "self",(char *) "pt", NULL
30540 };
30541
30542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30544 if (SWIG_arg_fail(1)) SWIG_fail;
30545 {
30546 arg2 = &temp2;
30547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30548 }
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30552
30553 wxPyEndAllowThreads(__tstate);
30554 if (PyErr_Occurred()) SWIG_fail;
30555 }
30556 {
30557 wxPoint * resultptr;
30558 resultptr = new wxPoint((wxPoint &)(result));
30559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30560 }
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30568 PyObject *resultobj;
30569 wxWindow *arg1 = (wxWindow *) 0 ;
30570 int arg2 ;
30571 int arg3 ;
30572 wxHitTest result;
30573 PyObject * obj0 = 0 ;
30574 PyObject * obj1 = 0 ;
30575 PyObject * obj2 = 0 ;
30576 char *kwnames[] = {
30577 (char *) "self",(char *) "x",(char *) "y", NULL
30578 };
30579
30580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30582 if (SWIG_arg_fail(1)) SWIG_fail;
30583 {
30584 arg2 = (int)(SWIG_As_int(obj1));
30585 if (SWIG_arg_fail(2)) SWIG_fail;
30586 }
30587 {
30588 arg3 = (int)(SWIG_As_int(obj2));
30589 if (SWIG_arg_fail(3)) SWIG_fail;
30590 }
30591 {
30592 PyThreadState* __tstate = wxPyBeginAllowThreads();
30593 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30594
30595 wxPyEndAllowThreads(__tstate);
30596 if (PyErr_Occurred()) SWIG_fail;
30597 }
30598 resultobj = SWIG_From_int((result));
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30606 PyObject *resultobj;
30607 wxWindow *arg1 = (wxWindow *) 0 ;
30608 wxPoint *arg2 = 0 ;
30609 wxHitTest result;
30610 wxPoint temp2 ;
30611 PyObject * obj0 = 0 ;
30612 PyObject * obj1 = 0 ;
30613 char *kwnames[] = {
30614 (char *) "self",(char *) "pt", NULL
30615 };
30616
30617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30619 if (SWIG_arg_fail(1)) SWIG_fail;
30620 {
30621 arg2 = &temp2;
30622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30623 }
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30627
30628 wxPyEndAllowThreads(__tstate);
30629 if (PyErr_Occurred()) SWIG_fail;
30630 }
30631 resultobj = SWIG_From_int((result));
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30639 PyObject *resultobj;
30640 wxWindow *arg1 = (wxWindow *) 0 ;
30641 long arg2 ;
30642 wxBorder result;
30643 PyObject * obj0 = 0 ;
30644 PyObject * obj1 = 0 ;
30645
30646 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30648 if (SWIG_arg_fail(1)) SWIG_fail;
30649 {
30650 arg2 = (long)(SWIG_As_long(obj1));
30651 if (SWIG_arg_fail(2)) SWIG_fail;
30652 }
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30656
30657 wxPyEndAllowThreads(__tstate);
30658 if (PyErr_Occurred()) SWIG_fail;
30659 }
30660 resultobj = SWIG_From_int((result));
30661 return resultobj;
30662 fail:
30663 return NULL;
30664 }
30665
30666
30667 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30668 PyObject *resultobj;
30669 wxWindow *arg1 = (wxWindow *) 0 ;
30670 wxBorder result;
30671 PyObject * obj0 = 0 ;
30672
30673 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30675 if (SWIG_arg_fail(1)) SWIG_fail;
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30679
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 resultobj = SWIG_From_int((result));
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30691 int argc;
30692 PyObject *argv[3];
30693 int ii;
30694
30695 argc = PyObject_Length(args);
30696 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30697 argv[ii] = PyTuple_GetItem(args,ii);
30698 }
30699 if (argc == 1) {
30700 int _v;
30701 {
30702 void *ptr;
30703 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30704 _v = 0;
30705 PyErr_Clear();
30706 } else {
30707 _v = 1;
30708 }
30709 }
30710 if (_v) {
30711 return _wrap_Window_GetBorder__SWIG_1(self,args);
30712 }
30713 }
30714 if (argc == 2) {
30715 int _v;
30716 {
30717 void *ptr;
30718 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30719 _v = 0;
30720 PyErr_Clear();
30721 } else {
30722 _v = 1;
30723 }
30724 }
30725 if (_v) {
30726 _v = SWIG_Check_long(argv[1]);
30727 if (_v) {
30728 return _wrap_Window_GetBorder__SWIG_0(self,args);
30729 }
30730 }
30731 }
30732
30733 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30734 return NULL;
30735 }
30736
30737
30738 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30739 PyObject *resultobj;
30740 wxWindow *arg1 = (wxWindow *) 0 ;
30741 long arg2 = (long) wxUPDATE_UI_NONE ;
30742 PyObject * obj0 = 0 ;
30743 PyObject * obj1 = 0 ;
30744 char *kwnames[] = {
30745 (char *) "self",(char *) "flags", NULL
30746 };
30747
30748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30750 if (SWIG_arg_fail(1)) SWIG_fail;
30751 if (obj1) {
30752 {
30753 arg2 = (long)(SWIG_As_long(obj1));
30754 if (SWIG_arg_fail(2)) SWIG_fail;
30755 }
30756 }
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 (arg1)->UpdateWindowUI(arg2);
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 Py_INCREF(Py_None); resultobj = Py_None;
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30772 PyObject *resultobj;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 wxMenu *arg2 = (wxMenu *) 0 ;
30775 int arg3 = (int) -1 ;
30776 int arg4 = (int) -1 ;
30777 bool result;
30778 PyObject * obj0 = 0 ;
30779 PyObject * obj1 = 0 ;
30780 PyObject * obj2 = 0 ;
30781 PyObject * obj3 = 0 ;
30782 char *kwnames[] = {
30783 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30784 };
30785
30786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30788 if (SWIG_arg_fail(1)) SWIG_fail;
30789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30790 if (SWIG_arg_fail(2)) SWIG_fail;
30791 if (obj2) {
30792 {
30793 arg3 = (int)(SWIG_As_int(obj2));
30794 if (SWIG_arg_fail(3)) SWIG_fail;
30795 }
30796 }
30797 if (obj3) {
30798 {
30799 arg4 = (int)(SWIG_As_int(obj3));
30800 if (SWIG_arg_fail(4)) SWIG_fail;
30801 }
30802 }
30803 {
30804 PyThreadState* __tstate = wxPyBeginAllowThreads();
30805 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30806
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 {
30811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30812 }
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30820 PyObject *resultobj;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 wxMenu *arg2 = (wxMenu *) 0 ;
30823 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30824 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30825 bool result;
30826 wxPoint temp3 ;
30827 PyObject * obj0 = 0 ;
30828 PyObject * obj1 = 0 ;
30829 PyObject * obj2 = 0 ;
30830 char *kwnames[] = {
30831 (char *) "self",(char *) "menu",(char *) "pos", NULL
30832 };
30833
30834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30836 if (SWIG_arg_fail(1)) SWIG_fail;
30837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30838 if (SWIG_arg_fail(2)) SWIG_fail;
30839 if (obj2) {
30840 {
30841 arg3 = &temp3;
30842 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30843 }
30844 }
30845 {
30846 PyThreadState* __tstate = wxPyBeginAllowThreads();
30847 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30848
30849 wxPyEndAllowThreads(__tstate);
30850 if (PyErr_Occurred()) SWIG_fail;
30851 }
30852 {
30853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30854 }
30855 return resultobj;
30856 fail:
30857 return NULL;
30858 }
30859
30860
30861 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30862 PyObject *resultobj;
30863 wxWindow *arg1 = (wxWindow *) 0 ;
30864 long result;
30865 PyObject * obj0 = 0 ;
30866 char *kwnames[] = {
30867 (char *) "self", NULL
30868 };
30869
30870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30872 if (SWIG_arg_fail(1)) SWIG_fail;
30873 {
30874 PyThreadState* __tstate = wxPyBeginAllowThreads();
30875 result = (long)wxWindow_GetHandle(arg1);
30876
30877 wxPyEndAllowThreads(__tstate);
30878 if (PyErr_Occurred()) SWIG_fail;
30879 }
30880 {
30881 resultobj = SWIG_From_long((long)(result));
30882 }
30883 return resultobj;
30884 fail:
30885 return NULL;
30886 }
30887
30888
30889 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30890 PyObject *resultobj;
30891 wxWindow *arg1 = (wxWindow *) 0 ;
30892 long arg2 ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 char *kwnames[] = {
30896 (char *) "self",(char *) "handle", NULL
30897 };
30898
30899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30901 if (SWIG_arg_fail(1)) SWIG_fail;
30902 {
30903 arg2 = (long)(SWIG_As_long(obj1));
30904 if (SWIG_arg_fail(2)) SWIG_fail;
30905 }
30906 {
30907 PyThreadState* __tstate = wxPyBeginAllowThreads();
30908 wxWindow_AssociateHandle(arg1,arg2);
30909
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 Py_INCREF(Py_None); resultobj = Py_None;
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj;
30922 wxWindow *arg1 = (wxWindow *) 0 ;
30923 PyObject * obj0 = 0 ;
30924 char *kwnames[] = {
30925 (char *) "self", NULL
30926 };
30927
30928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30930 if (SWIG_arg_fail(1)) SWIG_fail;
30931 {
30932 PyThreadState* __tstate = wxPyBeginAllowThreads();
30933 (arg1)->DissociateHandle();
30934
30935 wxPyEndAllowThreads(__tstate);
30936 if (PyErr_Occurred()) SWIG_fail;
30937 }
30938 Py_INCREF(Py_None); resultobj = Py_None;
30939 return resultobj;
30940 fail:
30941 return NULL;
30942 }
30943
30944
30945 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30946 PyObject *resultobj;
30947 wxWindow *arg1 = (wxWindow *) 0 ;
30948 int arg2 ;
30949 bool result;
30950 PyObject * obj0 = 0 ;
30951 PyObject * obj1 = 0 ;
30952 char *kwnames[] = {
30953 (char *) "self",(char *) "orient", NULL
30954 };
30955
30956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30958 if (SWIG_arg_fail(1)) SWIG_fail;
30959 {
30960 arg2 = (int)(SWIG_As_int(obj1));
30961 if (SWIG_arg_fail(2)) SWIG_fail;
30962 }
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30966
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 {
30971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30972 }
30973 return resultobj;
30974 fail:
30975 return NULL;
30976 }
30977
30978
30979 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30980 PyObject *resultobj;
30981 wxWindow *arg1 = (wxWindow *) 0 ;
30982 int arg2 ;
30983 int arg3 ;
30984 int arg4 ;
30985 int arg5 ;
30986 bool arg6 = (bool) true ;
30987 PyObject * obj0 = 0 ;
30988 PyObject * obj1 = 0 ;
30989 PyObject * obj2 = 0 ;
30990 PyObject * obj3 = 0 ;
30991 PyObject * obj4 = 0 ;
30992 PyObject * obj5 = 0 ;
30993 char *kwnames[] = {
30994 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30995 };
30996
30997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30999 if (SWIG_arg_fail(1)) SWIG_fail;
31000 {
31001 arg2 = (int)(SWIG_As_int(obj1));
31002 if (SWIG_arg_fail(2)) SWIG_fail;
31003 }
31004 {
31005 arg3 = (int)(SWIG_As_int(obj2));
31006 if (SWIG_arg_fail(3)) SWIG_fail;
31007 }
31008 {
31009 arg4 = (int)(SWIG_As_int(obj3));
31010 if (SWIG_arg_fail(4)) SWIG_fail;
31011 }
31012 {
31013 arg5 = (int)(SWIG_As_int(obj4));
31014 if (SWIG_arg_fail(5)) SWIG_fail;
31015 }
31016 if (obj5) {
31017 {
31018 arg6 = (bool)(SWIG_As_bool(obj5));
31019 if (SWIG_arg_fail(6)) SWIG_fail;
31020 }
31021 }
31022 {
31023 PyThreadState* __tstate = wxPyBeginAllowThreads();
31024 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31025
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 Py_INCREF(Py_None); resultobj = Py_None;
31030 return resultobj;
31031 fail:
31032 return NULL;
31033 }
31034
31035
31036 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31037 PyObject *resultobj;
31038 wxWindow *arg1 = (wxWindow *) 0 ;
31039 int arg2 ;
31040 int arg3 ;
31041 bool arg4 = (bool) true ;
31042 PyObject * obj0 = 0 ;
31043 PyObject * obj1 = 0 ;
31044 PyObject * obj2 = 0 ;
31045 PyObject * obj3 = 0 ;
31046 char *kwnames[] = {
31047 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31048 };
31049
31050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31052 if (SWIG_arg_fail(1)) SWIG_fail;
31053 {
31054 arg2 = (int)(SWIG_As_int(obj1));
31055 if (SWIG_arg_fail(2)) SWIG_fail;
31056 }
31057 {
31058 arg3 = (int)(SWIG_As_int(obj2));
31059 if (SWIG_arg_fail(3)) SWIG_fail;
31060 }
31061 if (obj3) {
31062 {
31063 arg4 = (bool)(SWIG_As_bool(obj3));
31064 if (SWIG_arg_fail(4)) SWIG_fail;
31065 }
31066 }
31067 {
31068 PyThreadState* __tstate = wxPyBeginAllowThreads();
31069 (arg1)->SetScrollPos(arg2,arg3,arg4);
31070
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 Py_INCREF(Py_None); resultobj = Py_None;
31075 return resultobj;
31076 fail:
31077 return NULL;
31078 }
31079
31080
31081 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31082 PyObject *resultobj;
31083 wxWindow *arg1 = (wxWindow *) 0 ;
31084 int arg2 ;
31085 int result;
31086 PyObject * obj0 = 0 ;
31087 PyObject * obj1 = 0 ;
31088 char *kwnames[] = {
31089 (char *) "self",(char *) "orientation", NULL
31090 };
31091
31092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31094 if (SWIG_arg_fail(1)) SWIG_fail;
31095 {
31096 arg2 = (int)(SWIG_As_int(obj1));
31097 if (SWIG_arg_fail(2)) SWIG_fail;
31098 }
31099 {
31100 PyThreadState* __tstate = wxPyBeginAllowThreads();
31101 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31102
31103 wxPyEndAllowThreads(__tstate);
31104 if (PyErr_Occurred()) SWIG_fail;
31105 }
31106 {
31107 resultobj = SWIG_From_int((int)(result));
31108 }
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 int arg2 ;
31119 int result;
31120 PyObject * obj0 = 0 ;
31121 PyObject * obj1 = 0 ;
31122 char *kwnames[] = {
31123 (char *) "self",(char *) "orientation", NULL
31124 };
31125
31126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31128 if (SWIG_arg_fail(1)) SWIG_fail;
31129 {
31130 arg2 = (int)(SWIG_As_int(obj1));
31131 if (SWIG_arg_fail(2)) SWIG_fail;
31132 }
31133 {
31134 PyThreadState* __tstate = wxPyBeginAllowThreads();
31135 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31136
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 {
31141 resultobj = SWIG_From_int((int)(result));
31142 }
31143 return resultobj;
31144 fail:
31145 return NULL;
31146 }
31147
31148
31149 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31150 PyObject *resultobj;
31151 wxWindow *arg1 = (wxWindow *) 0 ;
31152 int arg2 ;
31153 int result;
31154 PyObject * obj0 = 0 ;
31155 PyObject * obj1 = 0 ;
31156 char *kwnames[] = {
31157 (char *) "self",(char *) "orientation", NULL
31158 };
31159
31160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31162 if (SWIG_arg_fail(1)) SWIG_fail;
31163 {
31164 arg2 = (int)(SWIG_As_int(obj1));
31165 if (SWIG_arg_fail(2)) SWIG_fail;
31166 }
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31170
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 {
31175 resultobj = SWIG_From_int((int)(result));
31176 }
31177 return resultobj;
31178 fail:
31179 return NULL;
31180 }
31181
31182
31183 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31184 PyObject *resultobj;
31185 wxWindow *arg1 = (wxWindow *) 0 ;
31186 int arg2 ;
31187 int arg3 ;
31188 wxRect *arg4 = (wxRect *) NULL ;
31189 PyObject * obj0 = 0 ;
31190 PyObject * obj1 = 0 ;
31191 PyObject * obj2 = 0 ;
31192 PyObject * obj3 = 0 ;
31193 char *kwnames[] = {
31194 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31195 };
31196
31197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31199 if (SWIG_arg_fail(1)) SWIG_fail;
31200 {
31201 arg2 = (int)(SWIG_As_int(obj1));
31202 if (SWIG_arg_fail(2)) SWIG_fail;
31203 }
31204 {
31205 arg3 = (int)(SWIG_As_int(obj2));
31206 if (SWIG_arg_fail(3)) SWIG_fail;
31207 }
31208 if (obj3) {
31209 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31210 if (SWIG_arg_fail(4)) SWIG_fail;
31211 }
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31215
31216 wxPyEndAllowThreads(__tstate);
31217 if (PyErr_Occurred()) SWIG_fail;
31218 }
31219 Py_INCREF(Py_None); resultobj = Py_None;
31220 return resultobj;
31221 fail:
31222 return NULL;
31223 }
31224
31225
31226 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31227 PyObject *resultobj;
31228 wxWindow *arg1 = (wxWindow *) 0 ;
31229 int arg2 ;
31230 bool result;
31231 PyObject * obj0 = 0 ;
31232 PyObject * obj1 = 0 ;
31233 char *kwnames[] = {
31234 (char *) "self",(char *) "lines", NULL
31235 };
31236
31237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31239 if (SWIG_arg_fail(1)) SWIG_fail;
31240 {
31241 arg2 = (int)(SWIG_As_int(obj1));
31242 if (SWIG_arg_fail(2)) SWIG_fail;
31243 }
31244 {
31245 PyThreadState* __tstate = wxPyBeginAllowThreads();
31246 result = (bool)(arg1)->ScrollLines(arg2);
31247
31248 wxPyEndAllowThreads(__tstate);
31249 if (PyErr_Occurred()) SWIG_fail;
31250 }
31251 {
31252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31253 }
31254 return resultobj;
31255 fail:
31256 return NULL;
31257 }
31258
31259
31260 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31261 PyObject *resultobj;
31262 wxWindow *arg1 = (wxWindow *) 0 ;
31263 int arg2 ;
31264 bool result;
31265 PyObject * obj0 = 0 ;
31266 PyObject * obj1 = 0 ;
31267 char *kwnames[] = {
31268 (char *) "self",(char *) "pages", NULL
31269 };
31270
31271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31273 if (SWIG_arg_fail(1)) SWIG_fail;
31274 {
31275 arg2 = (int)(SWIG_As_int(obj1));
31276 if (SWIG_arg_fail(2)) SWIG_fail;
31277 }
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = (bool)(arg1)->ScrollPages(arg2);
31281
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 {
31286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31287 }
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31295 PyObject *resultobj;
31296 wxWindow *arg1 = (wxWindow *) 0 ;
31297 bool result;
31298 PyObject * obj0 = 0 ;
31299 char *kwnames[] = {
31300 (char *) "self", NULL
31301 };
31302
31303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31305 if (SWIG_arg_fail(1)) SWIG_fail;
31306 {
31307 PyThreadState* __tstate = wxPyBeginAllowThreads();
31308 result = (bool)(arg1)->LineUp();
31309
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 {
31314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31315 }
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31323 PyObject *resultobj;
31324 wxWindow *arg1 = (wxWindow *) 0 ;
31325 bool result;
31326 PyObject * obj0 = 0 ;
31327 char *kwnames[] = {
31328 (char *) "self", NULL
31329 };
31330
31331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31333 if (SWIG_arg_fail(1)) SWIG_fail;
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 result = (bool)(arg1)->LineDown();
31337
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 {
31342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31343 }
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31351 PyObject *resultobj;
31352 wxWindow *arg1 = (wxWindow *) 0 ;
31353 bool result;
31354 PyObject * obj0 = 0 ;
31355 char *kwnames[] = {
31356 (char *) "self", NULL
31357 };
31358
31359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31361 if (SWIG_arg_fail(1)) SWIG_fail;
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 result = (bool)(arg1)->PageUp();
31365
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 {
31370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31371 }
31372 return resultobj;
31373 fail:
31374 return NULL;
31375 }
31376
31377
31378 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31379 PyObject *resultobj;
31380 wxWindow *arg1 = (wxWindow *) 0 ;
31381 bool result;
31382 PyObject * obj0 = 0 ;
31383 char *kwnames[] = {
31384 (char *) "self", NULL
31385 };
31386
31387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31389 if (SWIG_arg_fail(1)) SWIG_fail;
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = (bool)(arg1)->PageDown();
31393
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 {
31398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31399 }
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31407 PyObject *resultobj;
31408 wxWindow *arg1 = (wxWindow *) 0 ;
31409 wxString *arg2 = 0 ;
31410 bool temp2 = false ;
31411 PyObject * obj0 = 0 ;
31412 PyObject * obj1 = 0 ;
31413 char *kwnames[] = {
31414 (char *) "self",(char *) "text", NULL
31415 };
31416
31417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31419 if (SWIG_arg_fail(1)) SWIG_fail;
31420 {
31421 arg2 = wxString_in_helper(obj1);
31422 if (arg2 == NULL) SWIG_fail;
31423 temp2 = true;
31424 }
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 (arg1)->SetHelpText((wxString const &)*arg2);
31428
31429 wxPyEndAllowThreads(__tstate);
31430 if (PyErr_Occurred()) SWIG_fail;
31431 }
31432 Py_INCREF(Py_None); resultobj = Py_None;
31433 {
31434 if (temp2)
31435 delete arg2;
31436 }
31437 return resultobj;
31438 fail:
31439 {
31440 if (temp2)
31441 delete arg2;
31442 }
31443 return NULL;
31444 }
31445
31446
31447 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31448 PyObject *resultobj;
31449 wxWindow *arg1 = (wxWindow *) 0 ;
31450 wxString *arg2 = 0 ;
31451 bool temp2 = false ;
31452 PyObject * obj0 = 0 ;
31453 PyObject * obj1 = 0 ;
31454 char *kwnames[] = {
31455 (char *) "self",(char *) "text", NULL
31456 };
31457
31458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31460 if (SWIG_arg_fail(1)) SWIG_fail;
31461 {
31462 arg2 = wxString_in_helper(obj1);
31463 if (arg2 == NULL) SWIG_fail;
31464 temp2 = true;
31465 }
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31469
31470 wxPyEndAllowThreads(__tstate);
31471 if (PyErr_Occurred()) SWIG_fail;
31472 }
31473 Py_INCREF(Py_None); resultobj = Py_None;
31474 {
31475 if (temp2)
31476 delete arg2;
31477 }
31478 return resultobj;
31479 fail:
31480 {
31481 if (temp2)
31482 delete arg2;
31483 }
31484 return NULL;
31485 }
31486
31487
31488 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31489 PyObject *resultobj;
31490 wxWindow *arg1 = (wxWindow *) 0 ;
31491 wxString result;
31492 PyObject * obj0 = 0 ;
31493 char *kwnames[] = {
31494 (char *) "self", NULL
31495 };
31496
31497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31499 if (SWIG_arg_fail(1)) SWIG_fail;
31500 {
31501 PyThreadState* __tstate = wxPyBeginAllowThreads();
31502 result = ((wxWindow const *)arg1)->GetHelpText();
31503
31504 wxPyEndAllowThreads(__tstate);
31505 if (PyErr_Occurred()) SWIG_fail;
31506 }
31507 {
31508 #if wxUSE_UNICODE
31509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31510 #else
31511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31512 #endif
31513 }
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31521 PyObject *resultobj;
31522 wxWindow *arg1 = (wxWindow *) 0 ;
31523 wxString *arg2 = 0 ;
31524 bool temp2 = false ;
31525 PyObject * obj0 = 0 ;
31526 PyObject * obj1 = 0 ;
31527 char *kwnames[] = {
31528 (char *) "self",(char *) "tip", NULL
31529 };
31530
31531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31533 if (SWIG_arg_fail(1)) SWIG_fail;
31534 {
31535 arg2 = wxString_in_helper(obj1);
31536 if (arg2 == NULL) SWIG_fail;
31537 temp2 = true;
31538 }
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 (arg1)->SetToolTip((wxString const &)*arg2);
31542
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 Py_INCREF(Py_None); resultobj = Py_None;
31547 {
31548 if (temp2)
31549 delete arg2;
31550 }
31551 return resultobj;
31552 fail:
31553 {
31554 if (temp2)
31555 delete arg2;
31556 }
31557 return NULL;
31558 }
31559
31560
31561 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31562 PyObject *resultobj;
31563 wxWindow *arg1 = (wxWindow *) 0 ;
31564 wxToolTip *arg2 = (wxToolTip *) 0 ;
31565 PyObject * obj0 = 0 ;
31566 PyObject * obj1 = 0 ;
31567 char *kwnames[] = {
31568 (char *) "self",(char *) "tip", NULL
31569 };
31570
31571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31573 if (SWIG_arg_fail(1)) SWIG_fail;
31574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31575 if (SWIG_arg_fail(2)) SWIG_fail;
31576 {
31577 PyThreadState* __tstate = wxPyBeginAllowThreads();
31578 (arg1)->SetToolTip(arg2);
31579
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 Py_INCREF(Py_None); resultobj = Py_None;
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj;
31592 wxWindow *arg1 = (wxWindow *) 0 ;
31593 wxToolTip *result;
31594 PyObject * obj0 = 0 ;
31595 char *kwnames[] = {
31596 (char *) "self", NULL
31597 };
31598
31599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31601 if (SWIG_arg_fail(1)) SWIG_fail;
31602 {
31603 PyThreadState* __tstate = wxPyBeginAllowThreads();
31604 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31605
31606 wxPyEndAllowThreads(__tstate);
31607 if (PyErr_Occurred()) SWIG_fail;
31608 }
31609 {
31610 resultobj = wxPyMake_wxObject(result, 0);
31611 }
31612 return resultobj;
31613 fail:
31614 return NULL;
31615 }
31616
31617
31618 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31619 PyObject *resultobj;
31620 wxWindow *arg1 = (wxWindow *) 0 ;
31621 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31622 PyObject * obj0 = 0 ;
31623 PyObject * obj1 = 0 ;
31624 char *kwnames[] = {
31625 (char *) "self",(char *) "dropTarget", NULL
31626 };
31627
31628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31630 if (SWIG_arg_fail(1)) SWIG_fail;
31631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31632 if (SWIG_arg_fail(2)) SWIG_fail;
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 (arg1)->SetDropTarget(arg2);
31636
31637 wxPyEndAllowThreads(__tstate);
31638 if (PyErr_Occurred()) SWIG_fail;
31639 }
31640 Py_INCREF(Py_None); resultobj = Py_None;
31641 return resultobj;
31642 fail:
31643 return NULL;
31644 }
31645
31646
31647 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31648 PyObject *resultobj;
31649 wxWindow *arg1 = (wxWindow *) 0 ;
31650 wxPyDropTarget *result;
31651 PyObject * obj0 = 0 ;
31652 char *kwnames[] = {
31653 (char *) "self", NULL
31654 };
31655
31656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31658 if (SWIG_arg_fail(1)) SWIG_fail;
31659 {
31660 PyThreadState* __tstate = wxPyBeginAllowThreads();
31661 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31662
31663 wxPyEndAllowThreads(__tstate);
31664 if (PyErr_Occurred()) SWIG_fail;
31665 }
31666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31667 return resultobj;
31668 fail:
31669 return NULL;
31670 }
31671
31672
31673 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31674 PyObject *resultobj;
31675 wxWindow *arg1 = (wxWindow *) 0 ;
31676 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31677 PyObject * obj0 = 0 ;
31678 PyObject * obj1 = 0 ;
31679 char *kwnames[] = {
31680 (char *) "self",(char *) "constraints", NULL
31681 };
31682
31683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31685 if (SWIG_arg_fail(1)) SWIG_fail;
31686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31687 if (SWIG_arg_fail(2)) SWIG_fail;
31688 {
31689 PyThreadState* __tstate = wxPyBeginAllowThreads();
31690 (arg1)->SetConstraints(arg2);
31691
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 Py_INCREF(Py_None); resultobj = Py_None;
31696 return resultobj;
31697 fail:
31698 return NULL;
31699 }
31700
31701
31702 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31703 PyObject *resultobj;
31704 wxWindow *arg1 = (wxWindow *) 0 ;
31705 wxLayoutConstraints *result;
31706 PyObject * obj0 = 0 ;
31707 char *kwnames[] = {
31708 (char *) "self", NULL
31709 };
31710
31711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31713 if (SWIG_arg_fail(1)) SWIG_fail;
31714 {
31715 PyThreadState* __tstate = wxPyBeginAllowThreads();
31716 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31717
31718 wxPyEndAllowThreads(__tstate);
31719 if (PyErr_Occurred()) SWIG_fail;
31720 }
31721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31722 return resultobj;
31723 fail:
31724 return NULL;
31725 }
31726
31727
31728 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31729 PyObject *resultobj;
31730 wxWindow *arg1 = (wxWindow *) 0 ;
31731 bool arg2 ;
31732 PyObject * obj0 = 0 ;
31733 PyObject * obj1 = 0 ;
31734 char *kwnames[] = {
31735 (char *) "self",(char *) "autoLayout", NULL
31736 };
31737
31738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31740 if (SWIG_arg_fail(1)) SWIG_fail;
31741 {
31742 arg2 = (bool)(SWIG_As_bool(obj1));
31743 if (SWIG_arg_fail(2)) SWIG_fail;
31744 }
31745 {
31746 PyThreadState* __tstate = wxPyBeginAllowThreads();
31747 (arg1)->SetAutoLayout(arg2);
31748
31749 wxPyEndAllowThreads(__tstate);
31750 if (PyErr_Occurred()) SWIG_fail;
31751 }
31752 Py_INCREF(Py_None); resultobj = Py_None;
31753 return resultobj;
31754 fail:
31755 return NULL;
31756 }
31757
31758
31759 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31760 PyObject *resultobj;
31761 wxWindow *arg1 = (wxWindow *) 0 ;
31762 bool result;
31763 PyObject * obj0 = 0 ;
31764 char *kwnames[] = {
31765 (char *) "self", NULL
31766 };
31767
31768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31770 if (SWIG_arg_fail(1)) SWIG_fail;
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31774
31775 wxPyEndAllowThreads(__tstate);
31776 if (PyErr_Occurred()) SWIG_fail;
31777 }
31778 {
31779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31780 }
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31788 PyObject *resultobj;
31789 wxWindow *arg1 = (wxWindow *) 0 ;
31790 bool result;
31791 PyObject * obj0 = 0 ;
31792 char *kwnames[] = {
31793 (char *) "self", NULL
31794 };
31795
31796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31798 if (SWIG_arg_fail(1)) SWIG_fail;
31799 {
31800 PyThreadState* __tstate = wxPyBeginAllowThreads();
31801 result = (bool)(arg1)->Layout();
31802
31803 wxPyEndAllowThreads(__tstate);
31804 if (PyErr_Occurred()) SWIG_fail;
31805 }
31806 {
31807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31808 }
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31816 PyObject *resultobj;
31817 wxWindow *arg1 = (wxWindow *) 0 ;
31818 wxSizer *arg2 = (wxSizer *) 0 ;
31819 bool arg3 = (bool) true ;
31820 PyObject * obj0 = 0 ;
31821 PyObject * obj1 = 0 ;
31822 PyObject * obj2 = 0 ;
31823 char *kwnames[] = {
31824 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31825 };
31826
31827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31829 if (SWIG_arg_fail(1)) SWIG_fail;
31830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31831 if (SWIG_arg_fail(2)) SWIG_fail;
31832 if (obj2) {
31833 {
31834 arg3 = (bool)(SWIG_As_bool(obj2));
31835 if (SWIG_arg_fail(3)) SWIG_fail;
31836 }
31837 }
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 (arg1)->SetSizer(arg2,arg3);
31841
31842 wxPyEndAllowThreads(__tstate);
31843 if (PyErr_Occurred()) SWIG_fail;
31844 }
31845 Py_INCREF(Py_None); resultobj = Py_None;
31846 return resultobj;
31847 fail:
31848 return NULL;
31849 }
31850
31851
31852 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31853 PyObject *resultobj;
31854 wxWindow *arg1 = (wxWindow *) 0 ;
31855 wxSizer *arg2 = (wxSizer *) 0 ;
31856 bool arg3 = (bool) true ;
31857 PyObject * obj0 = 0 ;
31858 PyObject * obj1 = 0 ;
31859 PyObject * obj2 = 0 ;
31860 char *kwnames[] = {
31861 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31862 };
31863
31864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31866 if (SWIG_arg_fail(1)) SWIG_fail;
31867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31868 if (SWIG_arg_fail(2)) SWIG_fail;
31869 if (obj2) {
31870 {
31871 arg3 = (bool)(SWIG_As_bool(obj2));
31872 if (SWIG_arg_fail(3)) SWIG_fail;
31873 }
31874 }
31875 {
31876 PyThreadState* __tstate = wxPyBeginAllowThreads();
31877 (arg1)->SetSizerAndFit(arg2,arg3);
31878
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 Py_INCREF(Py_None); resultobj = Py_None;
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 wxSizer *result;
31893 PyObject * obj0 = 0 ;
31894 char *kwnames[] = {
31895 (char *) "self", NULL
31896 };
31897
31898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31900 if (SWIG_arg_fail(1)) SWIG_fail;
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31904
31905 wxPyEndAllowThreads(__tstate);
31906 if (PyErr_Occurred()) SWIG_fail;
31907 }
31908 {
31909 resultobj = wxPyMake_wxSizer(result, 0);
31910 }
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31918 PyObject *resultobj;
31919 wxWindow *arg1 = (wxWindow *) 0 ;
31920 wxSizer *arg2 = (wxSizer *) 0 ;
31921 PyObject * obj0 = 0 ;
31922 PyObject * obj1 = 0 ;
31923 char *kwnames[] = {
31924 (char *) "self",(char *) "sizer", NULL
31925 };
31926
31927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31929 if (SWIG_arg_fail(1)) SWIG_fail;
31930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31931 if (SWIG_arg_fail(2)) SWIG_fail;
31932 {
31933 PyThreadState* __tstate = wxPyBeginAllowThreads();
31934 (arg1)->SetContainingSizer(arg2);
31935
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 Py_INCREF(Py_None); resultobj = Py_None;
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31947 PyObject *resultobj;
31948 wxWindow *arg1 = (wxWindow *) 0 ;
31949 wxSizer *result;
31950 PyObject * obj0 = 0 ;
31951 char *kwnames[] = {
31952 (char *) "self", NULL
31953 };
31954
31955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31957 if (SWIG_arg_fail(1)) SWIG_fail;
31958 {
31959 PyThreadState* __tstate = wxPyBeginAllowThreads();
31960 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31961
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 {
31966 resultobj = wxPyMake_wxSizer(result, 0);
31967 }
31968 return resultobj;
31969 fail:
31970 return NULL;
31971 }
31972
31973
31974 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31975 PyObject *resultobj;
31976 wxWindow *arg1 = (wxWindow *) 0 ;
31977 PyObject * obj0 = 0 ;
31978 char *kwnames[] = {
31979 (char *) "self", NULL
31980 };
31981
31982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31984 if (SWIG_arg_fail(1)) SWIG_fail;
31985 {
31986 PyThreadState* __tstate = wxPyBeginAllowThreads();
31987 (arg1)->InheritAttributes();
31988
31989 wxPyEndAllowThreads(__tstate);
31990 if (PyErr_Occurred()) SWIG_fail;
31991 }
31992 Py_INCREF(Py_None); resultobj = Py_None;
31993 return resultobj;
31994 fail:
31995 return NULL;
31996 }
31997
31998
31999 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32000 PyObject *resultobj;
32001 wxWindow *arg1 = (wxWindow *) 0 ;
32002 bool result;
32003 PyObject * obj0 = 0 ;
32004 char *kwnames[] = {
32005 (char *) "self", NULL
32006 };
32007
32008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32010 if (SWIG_arg_fail(1)) SWIG_fail;
32011 {
32012 PyThreadState* __tstate = wxPyBeginAllowThreads();
32013 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32014
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 {
32019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32020 }
32021 return resultobj;
32022 fail:
32023 return NULL;
32024 }
32025
32026
32027 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32028 PyObject *obj;
32029 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32030 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32031 Py_INCREF(obj);
32032 return Py_BuildValue((char *)"");
32033 }
32034 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32035 PyObject *resultobj;
32036 long arg1 ;
32037 wxWindow *arg2 = (wxWindow *) NULL ;
32038 wxWindow *result;
32039 PyObject * obj0 = 0 ;
32040 PyObject * obj1 = 0 ;
32041 char *kwnames[] = {
32042 (char *) "id",(char *) "parent", NULL
32043 };
32044
32045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32046 {
32047 arg1 = (long)(SWIG_As_long(obj0));
32048 if (SWIG_arg_fail(1)) SWIG_fail;
32049 }
32050 if (obj1) {
32051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32052 if (SWIG_arg_fail(2)) SWIG_fail;
32053 }
32054 {
32055 if (!wxPyCheckForApp()) SWIG_fail;
32056 PyThreadState* __tstate = wxPyBeginAllowThreads();
32057 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32058
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 {
32063 resultobj = wxPyMake_wxObject(result, 0);
32064 }
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32072 PyObject *resultobj;
32073 wxString *arg1 = 0 ;
32074 wxWindow *arg2 = (wxWindow *) NULL ;
32075 wxWindow *result;
32076 bool temp1 = false ;
32077 PyObject * obj0 = 0 ;
32078 PyObject * obj1 = 0 ;
32079 char *kwnames[] = {
32080 (char *) "name",(char *) "parent", NULL
32081 };
32082
32083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32084 {
32085 arg1 = wxString_in_helper(obj0);
32086 if (arg1 == NULL) SWIG_fail;
32087 temp1 = true;
32088 }
32089 if (obj1) {
32090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32091 if (SWIG_arg_fail(2)) SWIG_fail;
32092 }
32093 {
32094 if (!wxPyCheckForApp()) SWIG_fail;
32095 PyThreadState* __tstate = wxPyBeginAllowThreads();
32096 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32097
32098 wxPyEndAllowThreads(__tstate);
32099 if (PyErr_Occurred()) SWIG_fail;
32100 }
32101 {
32102 resultobj = wxPyMake_wxObject(result, 0);
32103 }
32104 {
32105 if (temp1)
32106 delete arg1;
32107 }
32108 return resultobj;
32109 fail:
32110 {
32111 if (temp1)
32112 delete arg1;
32113 }
32114 return NULL;
32115 }
32116
32117
32118 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32119 PyObject *resultobj;
32120 wxString *arg1 = 0 ;
32121 wxWindow *arg2 = (wxWindow *) NULL ;
32122 wxWindow *result;
32123 bool temp1 = false ;
32124 PyObject * obj0 = 0 ;
32125 PyObject * obj1 = 0 ;
32126 char *kwnames[] = {
32127 (char *) "label",(char *) "parent", NULL
32128 };
32129
32130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32131 {
32132 arg1 = wxString_in_helper(obj0);
32133 if (arg1 == NULL) SWIG_fail;
32134 temp1 = true;
32135 }
32136 if (obj1) {
32137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32138 if (SWIG_arg_fail(2)) SWIG_fail;
32139 }
32140 {
32141 if (!wxPyCheckForApp()) SWIG_fail;
32142 PyThreadState* __tstate = wxPyBeginAllowThreads();
32143 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32144
32145 wxPyEndAllowThreads(__tstate);
32146 if (PyErr_Occurred()) SWIG_fail;
32147 }
32148 {
32149 resultobj = wxPyMake_wxObject(result, 0);
32150 }
32151 {
32152 if (temp1)
32153 delete arg1;
32154 }
32155 return resultobj;
32156 fail:
32157 {
32158 if (temp1)
32159 delete arg1;
32160 }
32161 return NULL;
32162 }
32163
32164
32165 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32166 PyObject *resultobj;
32167 wxWindow *arg1 = (wxWindow *) 0 ;
32168 unsigned long arg2 ;
32169 wxWindow *result;
32170 PyObject * obj0 = 0 ;
32171 PyObject * obj1 = 0 ;
32172 char *kwnames[] = {
32173 (char *) "parent",(char *) "_hWnd", NULL
32174 };
32175
32176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32178 if (SWIG_arg_fail(1)) SWIG_fail;
32179 {
32180 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32181 if (SWIG_arg_fail(2)) SWIG_fail;
32182 }
32183 {
32184 PyThreadState* __tstate = wxPyBeginAllowThreads();
32185 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32186
32187 wxPyEndAllowThreads(__tstate);
32188 if (PyErr_Occurred()) SWIG_fail;
32189 }
32190 {
32191 resultobj = wxPyMake_wxObject(result, 0);
32192 }
32193 return resultobj;
32194 fail:
32195 return NULL;
32196 }
32197
32198
32199 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32200 PyObject *resultobj;
32201 wxValidator *result;
32202 char *kwnames[] = {
32203 NULL
32204 };
32205
32206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32207 {
32208 PyThreadState* __tstate = wxPyBeginAllowThreads();
32209 result = (wxValidator *)new wxValidator();
32210
32211 wxPyEndAllowThreads(__tstate);
32212 if (PyErr_Occurred()) SWIG_fail;
32213 }
32214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32215 return resultobj;
32216 fail:
32217 return NULL;
32218 }
32219
32220
32221 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32222 PyObject *resultobj;
32223 wxValidator *arg1 = (wxValidator *) 0 ;
32224 wxValidator *result;
32225 PyObject * obj0 = 0 ;
32226 char *kwnames[] = {
32227 (char *) "self", NULL
32228 };
32229
32230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32232 if (SWIG_arg_fail(1)) SWIG_fail;
32233 {
32234 PyThreadState* __tstate = wxPyBeginAllowThreads();
32235 result = (wxValidator *)(arg1)->Clone();
32236
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 {
32241 resultobj = wxPyMake_wxObject(result, 0);
32242 }
32243 return resultobj;
32244 fail:
32245 return NULL;
32246 }
32247
32248
32249 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32250 PyObject *resultobj;
32251 wxValidator *arg1 = (wxValidator *) 0 ;
32252 wxWindow *arg2 = (wxWindow *) 0 ;
32253 bool result;
32254 PyObject * obj0 = 0 ;
32255 PyObject * obj1 = 0 ;
32256 char *kwnames[] = {
32257 (char *) "self",(char *) "parent", NULL
32258 };
32259
32260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32262 if (SWIG_arg_fail(1)) SWIG_fail;
32263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32264 if (SWIG_arg_fail(2)) SWIG_fail;
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 result = (bool)(arg1)->Validate(arg2);
32268
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 {
32273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32274 }
32275 return resultobj;
32276 fail:
32277 return NULL;
32278 }
32279
32280
32281 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32282 PyObject *resultobj;
32283 wxValidator *arg1 = (wxValidator *) 0 ;
32284 bool result;
32285 PyObject * obj0 = 0 ;
32286 char *kwnames[] = {
32287 (char *) "self", NULL
32288 };
32289
32290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32292 if (SWIG_arg_fail(1)) SWIG_fail;
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 result = (bool)(arg1)->TransferToWindow();
32296
32297 wxPyEndAllowThreads(__tstate);
32298 if (PyErr_Occurred()) SWIG_fail;
32299 }
32300 {
32301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32302 }
32303 return resultobj;
32304 fail:
32305 return NULL;
32306 }
32307
32308
32309 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32310 PyObject *resultobj;
32311 wxValidator *arg1 = (wxValidator *) 0 ;
32312 bool result;
32313 PyObject * obj0 = 0 ;
32314 char *kwnames[] = {
32315 (char *) "self", NULL
32316 };
32317
32318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32320 if (SWIG_arg_fail(1)) SWIG_fail;
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 result = (bool)(arg1)->TransferFromWindow();
32324
32325 wxPyEndAllowThreads(__tstate);
32326 if (PyErr_Occurred()) SWIG_fail;
32327 }
32328 {
32329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32330 }
32331 return resultobj;
32332 fail:
32333 return NULL;
32334 }
32335
32336
32337 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32338 PyObject *resultobj;
32339 wxValidator *arg1 = (wxValidator *) 0 ;
32340 wxWindow *result;
32341 PyObject * obj0 = 0 ;
32342 char *kwnames[] = {
32343 (char *) "self", NULL
32344 };
32345
32346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32348 if (SWIG_arg_fail(1)) SWIG_fail;
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 result = (wxWindow *)(arg1)->GetWindow();
32352
32353 wxPyEndAllowThreads(__tstate);
32354 if (PyErr_Occurred()) SWIG_fail;
32355 }
32356 {
32357 resultobj = wxPyMake_wxObject(result, 0);
32358 }
32359 return resultobj;
32360 fail:
32361 return NULL;
32362 }
32363
32364
32365 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32366 PyObject *resultobj;
32367 wxValidator *arg1 = (wxValidator *) 0 ;
32368 wxWindow *arg2 = (wxWindow *) 0 ;
32369 PyObject * obj0 = 0 ;
32370 PyObject * obj1 = 0 ;
32371 char *kwnames[] = {
32372 (char *) "self",(char *) "window", NULL
32373 };
32374
32375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32377 if (SWIG_arg_fail(1)) SWIG_fail;
32378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32379 if (SWIG_arg_fail(2)) SWIG_fail;
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 (arg1)->SetWindow(arg2);
32383
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 Py_INCREF(Py_None); resultobj = Py_None;
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32395 PyObject *resultobj;
32396 bool result;
32397 char *kwnames[] = {
32398 NULL
32399 };
32400
32401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32402 {
32403 PyThreadState* __tstate = wxPyBeginAllowThreads();
32404 result = (bool)wxValidator::IsSilent();
32405
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 {
32410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32411 }
32412 return resultobj;
32413 fail:
32414 return NULL;
32415 }
32416
32417
32418 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32419 PyObject *resultobj;
32420 int arg1 = (int) true ;
32421 PyObject * obj0 = 0 ;
32422 char *kwnames[] = {
32423 (char *) "doIt", NULL
32424 };
32425
32426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32427 if (obj0) {
32428 {
32429 arg1 = (int)(SWIG_As_int(obj0));
32430 if (SWIG_arg_fail(1)) SWIG_fail;
32431 }
32432 }
32433 {
32434 PyThreadState* __tstate = wxPyBeginAllowThreads();
32435 wxValidator::SetBellOnError(arg1);
32436
32437 wxPyEndAllowThreads(__tstate);
32438 if (PyErr_Occurred()) SWIG_fail;
32439 }
32440 Py_INCREF(Py_None); resultobj = Py_None;
32441 return resultobj;
32442 fail:
32443 return NULL;
32444 }
32445
32446
32447 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32448 PyObject *obj;
32449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32450 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32451 Py_INCREF(obj);
32452 return Py_BuildValue((char *)"");
32453 }
32454 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32455 PyObject *resultobj;
32456 wxPyValidator *result;
32457 char *kwnames[] = {
32458 NULL
32459 };
32460
32461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32462 {
32463 PyThreadState* __tstate = wxPyBeginAllowThreads();
32464 result = (wxPyValidator *)new wxPyValidator();
32465
32466 wxPyEndAllowThreads(__tstate);
32467 if (PyErr_Occurred()) SWIG_fail;
32468 }
32469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32470 return resultobj;
32471 fail:
32472 return NULL;
32473 }
32474
32475
32476 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32477 PyObject *resultobj;
32478 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32479 PyObject *arg2 = (PyObject *) 0 ;
32480 PyObject *arg3 = (PyObject *) 0 ;
32481 int arg4 = (int) true ;
32482 PyObject * obj0 = 0 ;
32483 PyObject * obj1 = 0 ;
32484 PyObject * obj2 = 0 ;
32485 PyObject * obj3 = 0 ;
32486 char *kwnames[] = {
32487 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32488 };
32489
32490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32492 if (SWIG_arg_fail(1)) SWIG_fail;
32493 arg2 = obj1;
32494 arg3 = obj2;
32495 if (obj3) {
32496 {
32497 arg4 = (int)(SWIG_As_int(obj3));
32498 if (SWIG_arg_fail(4)) SWIG_fail;
32499 }
32500 }
32501 {
32502 PyThreadState* __tstate = wxPyBeginAllowThreads();
32503 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32504
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 Py_INCREF(Py_None); resultobj = Py_None;
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32516 PyObject *obj;
32517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32518 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32519 Py_INCREF(obj);
32520 return Py_BuildValue((char *)"");
32521 }
32522 static int _wrap_DefaultValidator_set(PyObject *) {
32523 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32524 return 1;
32525 }
32526
32527
32528 static PyObject *_wrap_DefaultValidator_get(void) {
32529 PyObject *pyobj;
32530
32531 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32532 return pyobj;
32533 }
32534
32535
32536 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32537 PyObject *resultobj;
32538 wxString const &arg1_defvalue = wxPyEmptyString ;
32539 wxString *arg1 = (wxString *) &arg1_defvalue ;
32540 long arg2 = (long) 0 ;
32541 wxMenu *result;
32542 bool temp1 = false ;
32543 PyObject * obj0 = 0 ;
32544 PyObject * obj1 = 0 ;
32545 char *kwnames[] = {
32546 (char *) "title",(char *) "style", NULL
32547 };
32548
32549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32550 if (obj0) {
32551 {
32552 arg1 = wxString_in_helper(obj0);
32553 if (arg1 == NULL) SWIG_fail;
32554 temp1 = true;
32555 }
32556 }
32557 if (obj1) {
32558 {
32559 arg2 = (long)(SWIG_As_long(obj1));
32560 if (SWIG_arg_fail(2)) SWIG_fail;
32561 }
32562 }
32563 {
32564 if (!wxPyCheckForApp()) SWIG_fail;
32565 PyThreadState* __tstate = wxPyBeginAllowThreads();
32566 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32567
32568 wxPyEndAllowThreads(__tstate);
32569 if (PyErr_Occurred()) SWIG_fail;
32570 }
32571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32572 {
32573 if (temp1)
32574 delete arg1;
32575 }
32576 return resultobj;
32577 fail:
32578 {
32579 if (temp1)
32580 delete arg1;
32581 }
32582 return NULL;
32583 }
32584
32585
32586 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32587 PyObject *resultobj;
32588 wxMenu *arg1 = (wxMenu *) 0 ;
32589 int arg2 ;
32590 wxString *arg3 = 0 ;
32591 wxString const &arg4_defvalue = wxPyEmptyString ;
32592 wxString *arg4 = (wxString *) &arg4_defvalue ;
32593 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32594 wxMenuItem *result;
32595 bool temp3 = false ;
32596 bool temp4 = false ;
32597 PyObject * obj0 = 0 ;
32598 PyObject * obj1 = 0 ;
32599 PyObject * obj2 = 0 ;
32600 PyObject * obj3 = 0 ;
32601 PyObject * obj4 = 0 ;
32602 char *kwnames[] = {
32603 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32604 };
32605
32606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32608 if (SWIG_arg_fail(1)) SWIG_fail;
32609 {
32610 arg2 = (int)(SWIG_As_int(obj1));
32611 if (SWIG_arg_fail(2)) SWIG_fail;
32612 }
32613 {
32614 arg3 = wxString_in_helper(obj2);
32615 if (arg3 == NULL) SWIG_fail;
32616 temp3 = true;
32617 }
32618 if (obj3) {
32619 {
32620 arg4 = wxString_in_helper(obj3);
32621 if (arg4 == NULL) SWIG_fail;
32622 temp4 = true;
32623 }
32624 }
32625 if (obj4) {
32626 {
32627 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32628 if (SWIG_arg_fail(5)) SWIG_fail;
32629 }
32630 }
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32634
32635 wxPyEndAllowThreads(__tstate);
32636 if (PyErr_Occurred()) SWIG_fail;
32637 }
32638 {
32639 resultobj = wxPyMake_wxObject(result, 0);
32640 }
32641 {
32642 if (temp3)
32643 delete arg3;
32644 }
32645 {
32646 if (temp4)
32647 delete arg4;
32648 }
32649 return resultobj;
32650 fail:
32651 {
32652 if (temp3)
32653 delete arg3;
32654 }
32655 {
32656 if (temp4)
32657 delete arg4;
32658 }
32659 return NULL;
32660 }
32661
32662
32663 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32664 PyObject *resultobj;
32665 wxMenu *arg1 = (wxMenu *) 0 ;
32666 wxMenuItem *result;
32667 PyObject * obj0 = 0 ;
32668 char *kwnames[] = {
32669 (char *) "self", NULL
32670 };
32671
32672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32674 if (SWIG_arg_fail(1)) SWIG_fail;
32675 {
32676 PyThreadState* __tstate = wxPyBeginAllowThreads();
32677 result = (wxMenuItem *)(arg1)->AppendSeparator();
32678
32679 wxPyEndAllowThreads(__tstate);
32680 if (PyErr_Occurred()) SWIG_fail;
32681 }
32682 {
32683 resultobj = wxPyMake_wxObject(result, 0);
32684 }
32685 return resultobj;
32686 fail:
32687 return NULL;
32688 }
32689
32690
32691 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32692 PyObject *resultobj;
32693 wxMenu *arg1 = (wxMenu *) 0 ;
32694 int arg2 ;
32695 wxString *arg3 = 0 ;
32696 wxString const &arg4_defvalue = wxPyEmptyString ;
32697 wxString *arg4 = (wxString *) &arg4_defvalue ;
32698 wxMenuItem *result;
32699 bool temp3 = false ;
32700 bool temp4 = false ;
32701 PyObject * obj0 = 0 ;
32702 PyObject * obj1 = 0 ;
32703 PyObject * obj2 = 0 ;
32704 PyObject * obj3 = 0 ;
32705 char *kwnames[] = {
32706 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32707 };
32708
32709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32711 if (SWIG_arg_fail(1)) SWIG_fail;
32712 {
32713 arg2 = (int)(SWIG_As_int(obj1));
32714 if (SWIG_arg_fail(2)) SWIG_fail;
32715 }
32716 {
32717 arg3 = wxString_in_helper(obj2);
32718 if (arg3 == NULL) SWIG_fail;
32719 temp3 = true;
32720 }
32721 if (obj3) {
32722 {
32723 arg4 = wxString_in_helper(obj3);
32724 if (arg4 == NULL) SWIG_fail;
32725 temp4 = true;
32726 }
32727 }
32728 {
32729 PyThreadState* __tstate = wxPyBeginAllowThreads();
32730 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32731
32732 wxPyEndAllowThreads(__tstate);
32733 if (PyErr_Occurred()) SWIG_fail;
32734 }
32735 {
32736 resultobj = wxPyMake_wxObject(result, 0);
32737 }
32738 {
32739 if (temp3)
32740 delete arg3;
32741 }
32742 {
32743 if (temp4)
32744 delete arg4;
32745 }
32746 return resultobj;
32747 fail:
32748 {
32749 if (temp3)
32750 delete arg3;
32751 }
32752 {
32753 if (temp4)
32754 delete arg4;
32755 }
32756 return NULL;
32757 }
32758
32759
32760 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32761 PyObject *resultobj;
32762 wxMenu *arg1 = (wxMenu *) 0 ;
32763 int arg2 ;
32764 wxString *arg3 = 0 ;
32765 wxString const &arg4_defvalue = wxPyEmptyString ;
32766 wxString *arg4 = (wxString *) &arg4_defvalue ;
32767 wxMenuItem *result;
32768 bool temp3 = false ;
32769 bool temp4 = false ;
32770 PyObject * obj0 = 0 ;
32771 PyObject * obj1 = 0 ;
32772 PyObject * obj2 = 0 ;
32773 PyObject * obj3 = 0 ;
32774 char *kwnames[] = {
32775 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32776 };
32777
32778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32780 if (SWIG_arg_fail(1)) SWIG_fail;
32781 {
32782 arg2 = (int)(SWIG_As_int(obj1));
32783 if (SWIG_arg_fail(2)) SWIG_fail;
32784 }
32785 {
32786 arg3 = wxString_in_helper(obj2);
32787 if (arg3 == NULL) SWIG_fail;
32788 temp3 = true;
32789 }
32790 if (obj3) {
32791 {
32792 arg4 = wxString_in_helper(obj3);
32793 if (arg4 == NULL) SWIG_fail;
32794 temp4 = true;
32795 }
32796 }
32797 {
32798 PyThreadState* __tstate = wxPyBeginAllowThreads();
32799 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32800
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 {
32805 resultobj = wxPyMake_wxObject(result, 0);
32806 }
32807 {
32808 if (temp3)
32809 delete arg3;
32810 }
32811 {
32812 if (temp4)
32813 delete arg4;
32814 }
32815 return resultobj;
32816 fail:
32817 {
32818 if (temp3)
32819 delete arg3;
32820 }
32821 {
32822 if (temp4)
32823 delete arg4;
32824 }
32825 return NULL;
32826 }
32827
32828
32829 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32830 PyObject *resultobj;
32831 wxMenu *arg1 = (wxMenu *) 0 ;
32832 int arg2 ;
32833 wxString *arg3 = 0 ;
32834 wxMenu *arg4 = (wxMenu *) 0 ;
32835 wxString const &arg5_defvalue = wxPyEmptyString ;
32836 wxString *arg5 = (wxString *) &arg5_defvalue ;
32837 wxMenuItem *result;
32838 bool temp3 = false ;
32839 bool temp5 = false ;
32840 PyObject * obj0 = 0 ;
32841 PyObject * obj1 = 0 ;
32842 PyObject * obj2 = 0 ;
32843 PyObject * obj3 = 0 ;
32844 PyObject * obj4 = 0 ;
32845 char *kwnames[] = {
32846 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32847 };
32848
32849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32851 if (SWIG_arg_fail(1)) SWIG_fail;
32852 {
32853 arg2 = (int)(SWIG_As_int(obj1));
32854 if (SWIG_arg_fail(2)) SWIG_fail;
32855 }
32856 {
32857 arg3 = wxString_in_helper(obj2);
32858 if (arg3 == NULL) SWIG_fail;
32859 temp3 = true;
32860 }
32861 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32862 if (SWIG_arg_fail(4)) SWIG_fail;
32863 if (obj4) {
32864 {
32865 arg5 = wxString_in_helper(obj4);
32866 if (arg5 == NULL) SWIG_fail;
32867 temp5 = true;
32868 }
32869 }
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32873
32874 wxPyEndAllowThreads(__tstate);
32875 if (PyErr_Occurred()) SWIG_fail;
32876 }
32877 {
32878 resultobj = wxPyMake_wxObject(result, 0);
32879 }
32880 {
32881 if (temp3)
32882 delete arg3;
32883 }
32884 {
32885 if (temp5)
32886 delete arg5;
32887 }
32888 return resultobj;
32889 fail:
32890 {
32891 if (temp3)
32892 delete arg3;
32893 }
32894 {
32895 if (temp5)
32896 delete arg5;
32897 }
32898 return NULL;
32899 }
32900
32901
32902 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32903 PyObject *resultobj;
32904 wxMenu *arg1 = (wxMenu *) 0 ;
32905 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32906 wxMenuItem *result;
32907 PyObject * obj0 = 0 ;
32908 PyObject * obj1 = 0 ;
32909 char *kwnames[] = {
32910 (char *) "self",(char *) "item", NULL
32911 };
32912
32913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32915 if (SWIG_arg_fail(1)) SWIG_fail;
32916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32917 if (SWIG_arg_fail(2)) SWIG_fail;
32918 {
32919 PyThreadState* __tstate = wxPyBeginAllowThreads();
32920 result = (wxMenuItem *)(arg1)->Append(arg2);
32921
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 {
32926 resultobj = wxPyMake_wxObject(result, 0);
32927 }
32928 return resultobj;
32929 fail:
32930 return NULL;
32931 }
32932
32933
32934 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32935 PyObject *resultobj;
32936 wxMenu *arg1 = (wxMenu *) 0 ;
32937 PyObject * obj0 = 0 ;
32938 char *kwnames[] = {
32939 (char *) "self", NULL
32940 };
32941
32942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32944 if (SWIG_arg_fail(1)) SWIG_fail;
32945 {
32946 PyThreadState* __tstate = wxPyBeginAllowThreads();
32947 (arg1)->Break();
32948
32949 wxPyEndAllowThreads(__tstate);
32950 if (PyErr_Occurred()) SWIG_fail;
32951 }
32952 Py_INCREF(Py_None); resultobj = Py_None;
32953 return resultobj;
32954 fail:
32955 return NULL;
32956 }
32957
32958
32959 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32960 PyObject *resultobj;
32961 wxMenu *arg1 = (wxMenu *) 0 ;
32962 size_t arg2 ;
32963 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32964 wxMenuItem *result;
32965 PyObject * obj0 = 0 ;
32966 PyObject * obj1 = 0 ;
32967 PyObject * obj2 = 0 ;
32968 char *kwnames[] = {
32969 (char *) "self",(char *) "pos",(char *) "item", NULL
32970 };
32971
32972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32974 if (SWIG_arg_fail(1)) SWIG_fail;
32975 {
32976 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32977 if (SWIG_arg_fail(2)) SWIG_fail;
32978 }
32979 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32980 if (SWIG_arg_fail(3)) SWIG_fail;
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32984
32985 wxPyEndAllowThreads(__tstate);
32986 if (PyErr_Occurred()) SWIG_fail;
32987 }
32988 {
32989 resultobj = wxPyMake_wxObject(result, 0);
32990 }
32991 return resultobj;
32992 fail:
32993 return NULL;
32994 }
32995
32996
32997 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32998 PyObject *resultobj;
32999 wxMenu *arg1 = (wxMenu *) 0 ;
33000 size_t arg2 ;
33001 int arg3 ;
33002 wxString *arg4 = 0 ;
33003 wxString const &arg5_defvalue = wxPyEmptyString ;
33004 wxString *arg5 = (wxString *) &arg5_defvalue ;
33005 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33006 wxMenuItem *result;
33007 bool temp4 = false ;
33008 bool temp5 = false ;
33009 PyObject * obj0 = 0 ;
33010 PyObject * obj1 = 0 ;
33011 PyObject * obj2 = 0 ;
33012 PyObject * obj3 = 0 ;
33013 PyObject * obj4 = 0 ;
33014 PyObject * obj5 = 0 ;
33015 char *kwnames[] = {
33016 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33017 };
33018
33019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33021 if (SWIG_arg_fail(1)) SWIG_fail;
33022 {
33023 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33024 if (SWIG_arg_fail(2)) SWIG_fail;
33025 }
33026 {
33027 arg3 = (int)(SWIG_As_int(obj2));
33028 if (SWIG_arg_fail(3)) SWIG_fail;
33029 }
33030 {
33031 arg4 = wxString_in_helper(obj3);
33032 if (arg4 == NULL) SWIG_fail;
33033 temp4 = true;
33034 }
33035 if (obj4) {
33036 {
33037 arg5 = wxString_in_helper(obj4);
33038 if (arg5 == NULL) SWIG_fail;
33039 temp5 = true;
33040 }
33041 }
33042 if (obj5) {
33043 {
33044 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33045 if (SWIG_arg_fail(6)) SWIG_fail;
33046 }
33047 }
33048 {
33049 PyThreadState* __tstate = wxPyBeginAllowThreads();
33050 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33051
33052 wxPyEndAllowThreads(__tstate);
33053 if (PyErr_Occurred()) SWIG_fail;
33054 }
33055 {
33056 resultobj = wxPyMake_wxObject(result, 0);
33057 }
33058 {
33059 if (temp4)
33060 delete arg4;
33061 }
33062 {
33063 if (temp5)
33064 delete arg5;
33065 }
33066 return resultobj;
33067 fail:
33068 {
33069 if (temp4)
33070 delete arg4;
33071 }
33072 {
33073 if (temp5)
33074 delete arg5;
33075 }
33076 return NULL;
33077 }
33078
33079
33080 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33081 PyObject *resultobj;
33082 wxMenu *arg1 = (wxMenu *) 0 ;
33083 size_t arg2 ;
33084 wxMenuItem *result;
33085 PyObject * obj0 = 0 ;
33086 PyObject * obj1 = 0 ;
33087 char *kwnames[] = {
33088 (char *) "self",(char *) "pos", NULL
33089 };
33090
33091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33093 if (SWIG_arg_fail(1)) SWIG_fail;
33094 {
33095 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33096 if (SWIG_arg_fail(2)) SWIG_fail;
33097 }
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33101
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 {
33106 resultobj = wxPyMake_wxObject(result, 0);
33107 }
33108 return resultobj;
33109 fail:
33110 return NULL;
33111 }
33112
33113
33114 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33115 PyObject *resultobj;
33116 wxMenu *arg1 = (wxMenu *) 0 ;
33117 size_t arg2 ;
33118 int arg3 ;
33119 wxString *arg4 = 0 ;
33120 wxString const &arg5_defvalue = wxPyEmptyString ;
33121 wxString *arg5 = (wxString *) &arg5_defvalue ;
33122 wxMenuItem *result;
33123 bool temp4 = 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 *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33132 };
33133
33134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",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 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33139 if (SWIG_arg_fail(2)) SWIG_fail;
33140 }
33141 {
33142 arg3 = (int)(SWIG_As_int(obj2));
33143 if (SWIG_arg_fail(3)) SWIG_fail;
33144 }
33145 {
33146 arg4 = wxString_in_helper(obj3);
33147 if (arg4 == NULL) SWIG_fail;
33148 temp4 = true;
33149 }
33150 if (obj4) {
33151 {
33152 arg5 = wxString_in_helper(obj4);
33153 if (arg5 == NULL) SWIG_fail;
33154 temp5 = true;
33155 }
33156 }
33157 {
33158 PyThreadState* __tstate = wxPyBeginAllowThreads();
33159 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33160
33161 wxPyEndAllowThreads(__tstate);
33162 if (PyErr_Occurred()) SWIG_fail;
33163 }
33164 {
33165 resultobj = wxPyMake_wxObject(result, 0);
33166 }
33167 {
33168 if (temp4)
33169 delete arg4;
33170 }
33171 {
33172 if (temp5)
33173 delete arg5;
33174 }
33175 return resultobj;
33176 fail:
33177 {
33178 if (temp4)
33179 delete arg4;
33180 }
33181 {
33182 if (temp5)
33183 delete arg5;
33184 }
33185 return NULL;
33186 }
33187
33188
33189 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33190 PyObject *resultobj;
33191 wxMenu *arg1 = (wxMenu *) 0 ;
33192 size_t arg2 ;
33193 int arg3 ;
33194 wxString *arg4 = 0 ;
33195 wxString const &arg5_defvalue = wxPyEmptyString ;
33196 wxString *arg5 = (wxString *) &arg5_defvalue ;
33197 wxMenuItem *result;
33198 bool temp4 = false ;
33199 bool temp5 = false ;
33200 PyObject * obj0 = 0 ;
33201 PyObject * obj1 = 0 ;
33202 PyObject * obj2 = 0 ;
33203 PyObject * obj3 = 0 ;
33204 PyObject * obj4 = 0 ;
33205 char *kwnames[] = {
33206 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33207 };
33208
33209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33211 if (SWIG_arg_fail(1)) SWIG_fail;
33212 {
33213 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33214 if (SWIG_arg_fail(2)) SWIG_fail;
33215 }
33216 {
33217 arg3 = (int)(SWIG_As_int(obj2));
33218 if (SWIG_arg_fail(3)) SWIG_fail;
33219 }
33220 {
33221 arg4 = wxString_in_helper(obj3);
33222 if (arg4 == NULL) SWIG_fail;
33223 temp4 = true;
33224 }
33225 if (obj4) {
33226 {
33227 arg5 = wxString_in_helper(obj4);
33228 if (arg5 == NULL) SWIG_fail;
33229 temp5 = true;
33230 }
33231 }
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33235
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 {
33240 resultobj = wxPyMake_wxObject(result, 0);
33241 }
33242 {
33243 if (temp4)
33244 delete arg4;
33245 }
33246 {
33247 if (temp5)
33248 delete arg5;
33249 }
33250 return resultobj;
33251 fail:
33252 {
33253 if (temp4)
33254 delete arg4;
33255 }
33256 {
33257 if (temp5)
33258 delete arg5;
33259 }
33260 return NULL;
33261 }
33262
33263
33264 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj;
33266 wxMenu *arg1 = (wxMenu *) 0 ;
33267 size_t arg2 ;
33268 int arg3 ;
33269 wxString *arg4 = 0 ;
33270 wxMenu *arg5 = (wxMenu *) 0 ;
33271 wxString const &arg6_defvalue = wxPyEmptyString ;
33272 wxString *arg6 = (wxString *) &arg6_defvalue ;
33273 wxMenuItem *result;
33274 bool temp4 = false ;
33275 bool temp6 = false ;
33276 PyObject * obj0 = 0 ;
33277 PyObject * obj1 = 0 ;
33278 PyObject * obj2 = 0 ;
33279 PyObject * obj3 = 0 ;
33280 PyObject * obj4 = 0 ;
33281 PyObject * obj5 = 0 ;
33282 char *kwnames[] = {
33283 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33284 };
33285
33286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33288 if (SWIG_arg_fail(1)) SWIG_fail;
33289 {
33290 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33291 if (SWIG_arg_fail(2)) SWIG_fail;
33292 }
33293 {
33294 arg3 = (int)(SWIG_As_int(obj2));
33295 if (SWIG_arg_fail(3)) SWIG_fail;
33296 }
33297 {
33298 arg4 = wxString_in_helper(obj3);
33299 if (arg4 == NULL) SWIG_fail;
33300 temp4 = true;
33301 }
33302 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33303 if (SWIG_arg_fail(5)) SWIG_fail;
33304 if (obj5) {
33305 {
33306 arg6 = wxString_in_helper(obj5);
33307 if (arg6 == NULL) SWIG_fail;
33308 temp6 = true;
33309 }
33310 }
33311 {
33312 PyThreadState* __tstate = wxPyBeginAllowThreads();
33313 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33314
33315 wxPyEndAllowThreads(__tstate);
33316 if (PyErr_Occurred()) SWIG_fail;
33317 }
33318 {
33319 resultobj = wxPyMake_wxObject(result, 0);
33320 }
33321 {
33322 if (temp4)
33323 delete arg4;
33324 }
33325 {
33326 if (temp6)
33327 delete arg6;
33328 }
33329 return resultobj;
33330 fail:
33331 {
33332 if (temp4)
33333 delete arg4;
33334 }
33335 {
33336 if (temp6)
33337 delete arg6;
33338 }
33339 return NULL;
33340 }
33341
33342
33343 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33344 PyObject *resultobj;
33345 wxMenu *arg1 = (wxMenu *) 0 ;
33346 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33347 wxMenuItem *result;
33348 PyObject * obj0 = 0 ;
33349 PyObject * obj1 = 0 ;
33350 char *kwnames[] = {
33351 (char *) "self",(char *) "item", NULL
33352 };
33353
33354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33356 if (SWIG_arg_fail(1)) SWIG_fail;
33357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33358 if (SWIG_arg_fail(2)) SWIG_fail;
33359 {
33360 PyThreadState* __tstate = wxPyBeginAllowThreads();
33361 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33362
33363 wxPyEndAllowThreads(__tstate);
33364 if (PyErr_Occurred()) SWIG_fail;
33365 }
33366 {
33367 resultobj = wxPyMake_wxObject(result, 0);
33368 }
33369 return resultobj;
33370 fail:
33371 return NULL;
33372 }
33373
33374
33375 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33376 PyObject *resultobj;
33377 wxMenu *arg1 = (wxMenu *) 0 ;
33378 int arg2 ;
33379 wxString *arg3 = 0 ;
33380 wxString const &arg4_defvalue = wxPyEmptyString ;
33381 wxString *arg4 = (wxString *) &arg4_defvalue ;
33382 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33383 wxMenuItem *result;
33384 bool temp3 = false ;
33385 bool temp4 = false ;
33386 PyObject * obj0 = 0 ;
33387 PyObject * obj1 = 0 ;
33388 PyObject * obj2 = 0 ;
33389 PyObject * obj3 = 0 ;
33390 PyObject * obj4 = 0 ;
33391 char *kwnames[] = {
33392 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33393 };
33394
33395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33397 if (SWIG_arg_fail(1)) SWIG_fail;
33398 {
33399 arg2 = (int)(SWIG_As_int(obj1));
33400 if (SWIG_arg_fail(2)) SWIG_fail;
33401 }
33402 {
33403 arg3 = wxString_in_helper(obj2);
33404 if (arg3 == NULL) SWIG_fail;
33405 temp3 = true;
33406 }
33407 if (obj3) {
33408 {
33409 arg4 = wxString_in_helper(obj3);
33410 if (arg4 == NULL) SWIG_fail;
33411 temp4 = true;
33412 }
33413 }
33414 if (obj4) {
33415 {
33416 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33417 if (SWIG_arg_fail(5)) SWIG_fail;
33418 }
33419 }
33420 {
33421 PyThreadState* __tstate = wxPyBeginAllowThreads();
33422 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33423
33424 wxPyEndAllowThreads(__tstate);
33425 if (PyErr_Occurred()) SWIG_fail;
33426 }
33427 {
33428 resultobj = wxPyMake_wxObject(result, 0);
33429 }
33430 {
33431 if (temp3)
33432 delete arg3;
33433 }
33434 {
33435 if (temp4)
33436 delete arg4;
33437 }
33438 return resultobj;
33439 fail:
33440 {
33441 if (temp3)
33442 delete arg3;
33443 }
33444 {
33445 if (temp4)
33446 delete arg4;
33447 }
33448 return NULL;
33449 }
33450
33451
33452 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33453 PyObject *resultobj;
33454 wxMenu *arg1 = (wxMenu *) 0 ;
33455 wxMenuItem *result;
33456 PyObject * obj0 = 0 ;
33457 char *kwnames[] = {
33458 (char *) "self", NULL
33459 };
33460
33461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33463 if (SWIG_arg_fail(1)) SWIG_fail;
33464 {
33465 PyThreadState* __tstate = wxPyBeginAllowThreads();
33466 result = (wxMenuItem *)(arg1)->PrependSeparator();
33467
33468 wxPyEndAllowThreads(__tstate);
33469 if (PyErr_Occurred()) SWIG_fail;
33470 }
33471 {
33472 resultobj = wxPyMake_wxObject(result, 0);
33473 }
33474 return resultobj;
33475 fail:
33476 return NULL;
33477 }
33478
33479
33480 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33481 PyObject *resultobj;
33482 wxMenu *arg1 = (wxMenu *) 0 ;
33483 int arg2 ;
33484 wxString *arg3 = 0 ;
33485 wxString const &arg4_defvalue = wxPyEmptyString ;
33486 wxString *arg4 = (wxString *) &arg4_defvalue ;
33487 wxMenuItem *result;
33488 bool temp3 = false ;
33489 bool temp4 = false ;
33490 PyObject * obj0 = 0 ;
33491 PyObject * obj1 = 0 ;
33492 PyObject * obj2 = 0 ;
33493 PyObject * obj3 = 0 ;
33494 char *kwnames[] = {
33495 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33496 };
33497
33498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33500 if (SWIG_arg_fail(1)) SWIG_fail;
33501 {
33502 arg2 = (int)(SWIG_As_int(obj1));
33503 if (SWIG_arg_fail(2)) SWIG_fail;
33504 }
33505 {
33506 arg3 = wxString_in_helper(obj2);
33507 if (arg3 == NULL) SWIG_fail;
33508 temp3 = true;
33509 }
33510 if (obj3) {
33511 {
33512 arg4 = wxString_in_helper(obj3);
33513 if (arg4 == NULL) SWIG_fail;
33514 temp4 = true;
33515 }
33516 }
33517 {
33518 PyThreadState* __tstate = wxPyBeginAllowThreads();
33519 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33520
33521 wxPyEndAllowThreads(__tstate);
33522 if (PyErr_Occurred()) SWIG_fail;
33523 }
33524 {
33525 resultobj = wxPyMake_wxObject(result, 0);
33526 }
33527 {
33528 if (temp3)
33529 delete arg3;
33530 }
33531 {
33532 if (temp4)
33533 delete arg4;
33534 }
33535 return resultobj;
33536 fail:
33537 {
33538 if (temp3)
33539 delete arg3;
33540 }
33541 {
33542 if (temp4)
33543 delete arg4;
33544 }
33545 return NULL;
33546 }
33547
33548
33549 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33550 PyObject *resultobj;
33551 wxMenu *arg1 = (wxMenu *) 0 ;
33552 int arg2 ;
33553 wxString *arg3 = 0 ;
33554 wxString const &arg4_defvalue = wxPyEmptyString ;
33555 wxString *arg4 = (wxString *) &arg4_defvalue ;
33556 wxMenuItem *result;
33557 bool temp3 = false ;
33558 bool temp4 = false ;
33559 PyObject * obj0 = 0 ;
33560 PyObject * obj1 = 0 ;
33561 PyObject * obj2 = 0 ;
33562 PyObject * obj3 = 0 ;
33563 char *kwnames[] = {
33564 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33565 };
33566
33567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33569 if (SWIG_arg_fail(1)) SWIG_fail;
33570 {
33571 arg2 = (int)(SWIG_As_int(obj1));
33572 if (SWIG_arg_fail(2)) SWIG_fail;
33573 }
33574 {
33575 arg3 = wxString_in_helper(obj2);
33576 if (arg3 == NULL) SWIG_fail;
33577 temp3 = true;
33578 }
33579 if (obj3) {
33580 {
33581 arg4 = wxString_in_helper(obj3);
33582 if (arg4 == NULL) SWIG_fail;
33583 temp4 = true;
33584 }
33585 }
33586 {
33587 PyThreadState* __tstate = wxPyBeginAllowThreads();
33588 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33589
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 {
33594 resultobj = wxPyMake_wxObject(result, 0);
33595 }
33596 {
33597 if (temp3)
33598 delete arg3;
33599 }
33600 {
33601 if (temp4)
33602 delete arg4;
33603 }
33604 return resultobj;
33605 fail:
33606 {
33607 if (temp3)
33608 delete arg3;
33609 }
33610 {
33611 if (temp4)
33612 delete arg4;
33613 }
33614 return NULL;
33615 }
33616
33617
33618 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33619 PyObject *resultobj;
33620 wxMenu *arg1 = (wxMenu *) 0 ;
33621 int arg2 ;
33622 wxString *arg3 = 0 ;
33623 wxMenu *arg4 = (wxMenu *) 0 ;
33624 wxString const &arg5_defvalue = wxPyEmptyString ;
33625 wxString *arg5 = (wxString *) &arg5_defvalue ;
33626 wxMenuItem *result;
33627 bool temp3 = false ;
33628 bool temp5 = false ;
33629 PyObject * obj0 = 0 ;
33630 PyObject * obj1 = 0 ;
33631 PyObject * obj2 = 0 ;
33632 PyObject * obj3 = 0 ;
33633 PyObject * obj4 = 0 ;
33634 char *kwnames[] = {
33635 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33636 };
33637
33638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33640 if (SWIG_arg_fail(1)) SWIG_fail;
33641 {
33642 arg2 = (int)(SWIG_As_int(obj1));
33643 if (SWIG_arg_fail(2)) SWIG_fail;
33644 }
33645 {
33646 arg3 = wxString_in_helper(obj2);
33647 if (arg3 == NULL) SWIG_fail;
33648 temp3 = true;
33649 }
33650 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33651 if (SWIG_arg_fail(4)) SWIG_fail;
33652 if (obj4) {
33653 {
33654 arg5 = wxString_in_helper(obj4);
33655 if (arg5 == NULL) SWIG_fail;
33656 temp5 = true;
33657 }
33658 }
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33662
33663 wxPyEndAllowThreads(__tstate);
33664 if (PyErr_Occurred()) SWIG_fail;
33665 }
33666 {
33667 resultobj = wxPyMake_wxObject(result, 0);
33668 }
33669 {
33670 if (temp3)
33671 delete arg3;
33672 }
33673 {
33674 if (temp5)
33675 delete arg5;
33676 }
33677 return resultobj;
33678 fail:
33679 {
33680 if (temp3)
33681 delete arg3;
33682 }
33683 {
33684 if (temp5)
33685 delete arg5;
33686 }
33687 return NULL;
33688 }
33689
33690
33691 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33692 PyObject *resultobj;
33693 wxMenu *arg1 = (wxMenu *) 0 ;
33694 int arg2 ;
33695 wxMenuItem *result;
33696 PyObject * obj0 = 0 ;
33697 PyObject * obj1 = 0 ;
33698 char *kwnames[] = {
33699 (char *) "self",(char *) "id", NULL
33700 };
33701
33702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33704 if (SWIG_arg_fail(1)) SWIG_fail;
33705 {
33706 arg2 = (int)(SWIG_As_int(obj1));
33707 if (SWIG_arg_fail(2)) SWIG_fail;
33708 }
33709 {
33710 PyThreadState* __tstate = wxPyBeginAllowThreads();
33711 result = (wxMenuItem *)(arg1)->Remove(arg2);
33712
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 {
33717 resultobj = wxPyMake_wxObject(result, 0);
33718 }
33719 return resultobj;
33720 fail:
33721 return NULL;
33722 }
33723
33724
33725 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33726 PyObject *resultobj;
33727 wxMenu *arg1 = (wxMenu *) 0 ;
33728 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33729 wxMenuItem *result;
33730 PyObject * obj0 = 0 ;
33731 PyObject * obj1 = 0 ;
33732 char *kwnames[] = {
33733 (char *) "self",(char *) "item", NULL
33734 };
33735
33736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33738 if (SWIG_arg_fail(1)) SWIG_fail;
33739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33740 if (SWIG_arg_fail(2)) SWIG_fail;
33741 {
33742 PyThreadState* __tstate = wxPyBeginAllowThreads();
33743 result = (wxMenuItem *)(arg1)->Remove(arg2);
33744
33745 wxPyEndAllowThreads(__tstate);
33746 if (PyErr_Occurred()) SWIG_fail;
33747 }
33748 {
33749 resultobj = wxPyMake_wxObject(result, 0);
33750 }
33751 return resultobj;
33752 fail:
33753 return NULL;
33754 }
33755
33756
33757 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33758 PyObject *resultobj;
33759 wxMenu *arg1 = (wxMenu *) 0 ;
33760 int arg2 ;
33761 bool result;
33762 PyObject * obj0 = 0 ;
33763 PyObject * obj1 = 0 ;
33764 char *kwnames[] = {
33765 (char *) "self",(char *) "id", NULL
33766 };
33767
33768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33770 if (SWIG_arg_fail(1)) SWIG_fail;
33771 {
33772 arg2 = (int)(SWIG_As_int(obj1));
33773 if (SWIG_arg_fail(2)) SWIG_fail;
33774 }
33775 {
33776 PyThreadState* __tstate = wxPyBeginAllowThreads();
33777 result = (bool)(arg1)->Delete(arg2);
33778
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 {
33783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33784 }
33785 return resultobj;
33786 fail:
33787 return NULL;
33788 }
33789
33790
33791 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33792 PyObject *resultobj;
33793 wxMenu *arg1 = (wxMenu *) 0 ;
33794 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33795 bool result;
33796 PyObject * obj0 = 0 ;
33797 PyObject * obj1 = 0 ;
33798 char *kwnames[] = {
33799 (char *) "self",(char *) "item", NULL
33800 };
33801
33802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33804 if (SWIG_arg_fail(1)) SWIG_fail;
33805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33806 if (SWIG_arg_fail(2)) SWIG_fail;
33807 {
33808 PyThreadState* __tstate = wxPyBeginAllowThreads();
33809 result = (bool)(arg1)->Delete(arg2);
33810
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 {
33815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33816 }
33817 return resultobj;
33818 fail:
33819 return NULL;
33820 }
33821
33822
33823 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33824 PyObject *resultobj;
33825 wxMenu *arg1 = (wxMenu *) 0 ;
33826 PyObject * obj0 = 0 ;
33827 char *kwnames[] = {
33828 (char *) "self", NULL
33829 };
33830
33831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33833 if (SWIG_arg_fail(1)) SWIG_fail;
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 wxMenu_Destroy(arg1);
33837
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 Py_INCREF(Py_None); resultobj = Py_None;
33842 return resultobj;
33843 fail:
33844 return NULL;
33845 }
33846
33847
33848 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33849 PyObject *resultobj;
33850 wxMenu *arg1 = (wxMenu *) 0 ;
33851 int arg2 ;
33852 bool result;
33853 PyObject * obj0 = 0 ;
33854 PyObject * obj1 = 0 ;
33855 char *kwnames[] = {
33856 (char *) "self",(char *) "id", NULL
33857 };
33858
33859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33861 if (SWIG_arg_fail(1)) SWIG_fail;
33862 {
33863 arg2 = (int)(SWIG_As_int(obj1));
33864 if (SWIG_arg_fail(2)) SWIG_fail;
33865 }
33866 {
33867 PyThreadState* __tstate = wxPyBeginAllowThreads();
33868 result = (bool)(arg1)->Destroy(arg2);
33869
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 {
33874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33875 }
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj;
33884 wxMenu *arg1 = (wxMenu *) 0 ;
33885 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33886 bool result;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 char *kwnames[] = {
33890 (char *) "self",(char *) "item", NULL
33891 };
33892
33893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33895 if (SWIG_arg_fail(1)) SWIG_fail;
33896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33897 if (SWIG_arg_fail(2)) SWIG_fail;
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (bool)(arg1)->Destroy(arg2);
33901
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 {
33906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33907 }
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj;
33916 wxMenu *arg1 = (wxMenu *) 0 ;
33917 size_t result;
33918 PyObject * obj0 = 0 ;
33919 char *kwnames[] = {
33920 (char *) "self", NULL
33921 };
33922
33923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33925 if (SWIG_arg_fail(1)) SWIG_fail;
33926 {
33927 PyThreadState* __tstate = wxPyBeginAllowThreads();
33928 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33929
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 {
33934 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33935 }
33936 return resultobj;
33937 fail:
33938 return NULL;
33939 }
33940
33941
33942 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33943 PyObject *resultobj;
33944 wxMenu *arg1 = (wxMenu *) 0 ;
33945 PyObject *result;
33946 PyObject * obj0 = 0 ;
33947 char *kwnames[] = {
33948 (char *) "self", NULL
33949 };
33950
33951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33953 if (SWIG_arg_fail(1)) SWIG_fail;
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33957
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 resultobj = result;
33962 return resultobj;
33963 fail:
33964 return NULL;
33965 }
33966
33967
33968 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33969 PyObject *resultobj;
33970 wxMenu *arg1 = (wxMenu *) 0 ;
33971 wxString *arg2 = 0 ;
33972 int result;
33973 bool temp2 = false ;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 char *kwnames[] = {
33977 (char *) "self",(char *) "item", NULL
33978 };
33979
33980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33982 if (SWIG_arg_fail(1)) SWIG_fail;
33983 {
33984 arg2 = wxString_in_helper(obj1);
33985 if (arg2 == NULL) SWIG_fail;
33986 temp2 = true;
33987 }
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33991
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 {
33996 resultobj = SWIG_From_int((int)(result));
33997 }
33998 {
33999 if (temp2)
34000 delete arg2;
34001 }
34002 return resultobj;
34003 fail:
34004 {
34005 if (temp2)
34006 delete arg2;
34007 }
34008 return NULL;
34009 }
34010
34011
34012 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34013 PyObject *resultobj;
34014 wxMenu *arg1 = (wxMenu *) 0 ;
34015 int arg2 ;
34016 wxMenuItem *result;
34017 PyObject * obj0 = 0 ;
34018 PyObject * obj1 = 0 ;
34019 char *kwnames[] = {
34020 (char *) "self",(char *) "id", NULL
34021 };
34022
34023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34025 if (SWIG_arg_fail(1)) SWIG_fail;
34026 {
34027 arg2 = (int)(SWIG_As_int(obj1));
34028 if (SWIG_arg_fail(2)) SWIG_fail;
34029 }
34030 {
34031 PyThreadState* __tstate = wxPyBeginAllowThreads();
34032 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34033
34034 wxPyEndAllowThreads(__tstate);
34035 if (PyErr_Occurred()) SWIG_fail;
34036 }
34037 {
34038 resultobj = wxPyMake_wxObject(result, 0);
34039 }
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34047 PyObject *resultobj;
34048 wxMenu *arg1 = (wxMenu *) 0 ;
34049 size_t arg2 ;
34050 wxMenuItem *result;
34051 PyObject * obj0 = 0 ;
34052 PyObject * obj1 = 0 ;
34053 char *kwnames[] = {
34054 (char *) "self",(char *) "position", NULL
34055 };
34056
34057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34059 if (SWIG_arg_fail(1)) SWIG_fail;
34060 {
34061 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34062 if (SWIG_arg_fail(2)) SWIG_fail;
34063 }
34064 {
34065 PyThreadState* __tstate = wxPyBeginAllowThreads();
34066 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34067
34068 wxPyEndAllowThreads(__tstate);
34069 if (PyErr_Occurred()) SWIG_fail;
34070 }
34071 {
34072 resultobj = wxPyMake_wxObject(result, 0);
34073 }
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34081 PyObject *resultobj;
34082 wxMenu *arg1 = (wxMenu *) 0 ;
34083 int arg2 ;
34084 bool arg3 ;
34085 PyObject * obj0 = 0 ;
34086 PyObject * obj1 = 0 ;
34087 PyObject * obj2 = 0 ;
34088 char *kwnames[] = {
34089 (char *) "self",(char *) "id",(char *) "enable", NULL
34090 };
34091
34092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34094 if (SWIG_arg_fail(1)) SWIG_fail;
34095 {
34096 arg2 = (int)(SWIG_As_int(obj1));
34097 if (SWIG_arg_fail(2)) SWIG_fail;
34098 }
34099 {
34100 arg3 = (bool)(SWIG_As_bool(obj2));
34101 if (SWIG_arg_fail(3)) SWIG_fail;
34102 }
34103 {
34104 PyThreadState* __tstate = wxPyBeginAllowThreads();
34105 (arg1)->Enable(arg2,arg3);
34106
34107 wxPyEndAllowThreads(__tstate);
34108 if (PyErr_Occurred()) SWIG_fail;
34109 }
34110 Py_INCREF(Py_None); resultobj = Py_None;
34111 return resultobj;
34112 fail:
34113 return NULL;
34114 }
34115
34116
34117 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34118 PyObject *resultobj;
34119 wxMenu *arg1 = (wxMenu *) 0 ;
34120 int arg2 ;
34121 bool result;
34122 PyObject * obj0 = 0 ;
34123 PyObject * obj1 = 0 ;
34124 char *kwnames[] = {
34125 (char *) "self",(char *) "id", NULL
34126 };
34127
34128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34130 if (SWIG_arg_fail(1)) SWIG_fail;
34131 {
34132 arg2 = (int)(SWIG_As_int(obj1));
34133 if (SWIG_arg_fail(2)) SWIG_fail;
34134 }
34135 {
34136 PyThreadState* __tstate = wxPyBeginAllowThreads();
34137 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34138
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 {
34143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34144 }
34145 return resultobj;
34146 fail:
34147 return NULL;
34148 }
34149
34150
34151 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34152 PyObject *resultobj;
34153 wxMenu *arg1 = (wxMenu *) 0 ;
34154 int arg2 ;
34155 bool arg3 ;
34156 PyObject * obj0 = 0 ;
34157 PyObject * obj1 = 0 ;
34158 PyObject * obj2 = 0 ;
34159 char *kwnames[] = {
34160 (char *) "self",(char *) "id",(char *) "check", NULL
34161 };
34162
34163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34165 if (SWIG_arg_fail(1)) SWIG_fail;
34166 {
34167 arg2 = (int)(SWIG_As_int(obj1));
34168 if (SWIG_arg_fail(2)) SWIG_fail;
34169 }
34170 {
34171 arg3 = (bool)(SWIG_As_bool(obj2));
34172 if (SWIG_arg_fail(3)) SWIG_fail;
34173 }
34174 {
34175 PyThreadState* __tstate = wxPyBeginAllowThreads();
34176 (arg1)->Check(arg2,arg3);
34177
34178 wxPyEndAllowThreads(__tstate);
34179 if (PyErr_Occurred()) SWIG_fail;
34180 }
34181 Py_INCREF(Py_None); resultobj = Py_None;
34182 return resultobj;
34183 fail:
34184 return NULL;
34185 }
34186
34187
34188 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34189 PyObject *resultobj;
34190 wxMenu *arg1 = (wxMenu *) 0 ;
34191 int arg2 ;
34192 bool result;
34193 PyObject * obj0 = 0 ;
34194 PyObject * obj1 = 0 ;
34195 char *kwnames[] = {
34196 (char *) "self",(char *) "id", NULL
34197 };
34198
34199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
34204 if (SWIG_arg_fail(2)) SWIG_fail;
34205 }
34206 {
34207 PyThreadState* __tstate = wxPyBeginAllowThreads();
34208 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34209
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 {
34214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34215 }
34216 return resultobj;
34217 fail:
34218 return NULL;
34219 }
34220
34221
34222 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34223 PyObject *resultobj;
34224 wxMenu *arg1 = (wxMenu *) 0 ;
34225 int arg2 ;
34226 wxString *arg3 = 0 ;
34227 bool temp3 = false ;
34228 PyObject * obj0 = 0 ;
34229 PyObject * obj1 = 0 ;
34230 PyObject * obj2 = 0 ;
34231 char *kwnames[] = {
34232 (char *) "self",(char *) "id",(char *) "label", NULL
34233 };
34234
34235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34237 if (SWIG_arg_fail(1)) SWIG_fail;
34238 {
34239 arg2 = (int)(SWIG_As_int(obj1));
34240 if (SWIG_arg_fail(2)) SWIG_fail;
34241 }
34242 {
34243 arg3 = wxString_in_helper(obj2);
34244 if (arg3 == NULL) SWIG_fail;
34245 temp3 = true;
34246 }
34247 {
34248 PyThreadState* __tstate = wxPyBeginAllowThreads();
34249 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34250
34251 wxPyEndAllowThreads(__tstate);
34252 if (PyErr_Occurred()) SWIG_fail;
34253 }
34254 Py_INCREF(Py_None); resultobj = Py_None;
34255 {
34256 if (temp3)
34257 delete arg3;
34258 }
34259 return resultobj;
34260 fail:
34261 {
34262 if (temp3)
34263 delete arg3;
34264 }
34265 return NULL;
34266 }
34267
34268
34269 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34270 PyObject *resultobj;
34271 wxMenu *arg1 = (wxMenu *) 0 ;
34272 int arg2 ;
34273 wxString result;
34274 PyObject * obj0 = 0 ;
34275 PyObject * obj1 = 0 ;
34276 char *kwnames[] = {
34277 (char *) "self",(char *) "id", NULL
34278 };
34279
34280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34282 if (SWIG_arg_fail(1)) SWIG_fail;
34283 {
34284 arg2 = (int)(SWIG_As_int(obj1));
34285 if (SWIG_arg_fail(2)) SWIG_fail;
34286 }
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34290
34291 wxPyEndAllowThreads(__tstate);
34292 if (PyErr_Occurred()) SWIG_fail;
34293 }
34294 {
34295 #if wxUSE_UNICODE
34296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34297 #else
34298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34299 #endif
34300 }
34301 return resultobj;
34302 fail:
34303 return NULL;
34304 }
34305
34306
34307 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34308 PyObject *resultobj;
34309 wxMenu *arg1 = (wxMenu *) 0 ;
34310 int arg2 ;
34311 wxString *arg3 = 0 ;
34312 bool temp3 = false ;
34313 PyObject * obj0 = 0 ;
34314 PyObject * obj1 = 0 ;
34315 PyObject * obj2 = 0 ;
34316 char *kwnames[] = {
34317 (char *) "self",(char *) "id",(char *) "helpString", NULL
34318 };
34319
34320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34322 if (SWIG_arg_fail(1)) SWIG_fail;
34323 {
34324 arg2 = (int)(SWIG_As_int(obj1));
34325 if (SWIG_arg_fail(2)) SWIG_fail;
34326 }
34327 {
34328 arg3 = wxString_in_helper(obj2);
34329 if (arg3 == NULL) SWIG_fail;
34330 temp3 = true;
34331 }
34332 {
34333 PyThreadState* __tstate = wxPyBeginAllowThreads();
34334 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34335
34336 wxPyEndAllowThreads(__tstate);
34337 if (PyErr_Occurred()) SWIG_fail;
34338 }
34339 Py_INCREF(Py_None); resultobj = Py_None;
34340 {
34341 if (temp3)
34342 delete arg3;
34343 }
34344 return resultobj;
34345 fail:
34346 {
34347 if (temp3)
34348 delete arg3;
34349 }
34350 return NULL;
34351 }
34352
34353
34354 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34355 PyObject *resultobj;
34356 wxMenu *arg1 = (wxMenu *) 0 ;
34357 int arg2 ;
34358 wxString result;
34359 PyObject * obj0 = 0 ;
34360 PyObject * obj1 = 0 ;
34361 char *kwnames[] = {
34362 (char *) "self",(char *) "id", NULL
34363 };
34364
34365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34367 if (SWIG_arg_fail(1)) SWIG_fail;
34368 {
34369 arg2 = (int)(SWIG_As_int(obj1));
34370 if (SWIG_arg_fail(2)) SWIG_fail;
34371 }
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34375
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 {
34380 #if wxUSE_UNICODE
34381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34382 #else
34383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34384 #endif
34385 }
34386 return resultobj;
34387 fail:
34388 return NULL;
34389 }
34390
34391
34392 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34393 PyObject *resultobj;
34394 wxMenu *arg1 = (wxMenu *) 0 ;
34395 wxString *arg2 = 0 ;
34396 bool temp2 = false ;
34397 PyObject * obj0 = 0 ;
34398 PyObject * obj1 = 0 ;
34399 char *kwnames[] = {
34400 (char *) "self",(char *) "title", NULL
34401 };
34402
34403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34405 if (SWIG_arg_fail(1)) SWIG_fail;
34406 {
34407 arg2 = wxString_in_helper(obj1);
34408 if (arg2 == NULL) SWIG_fail;
34409 temp2 = true;
34410 }
34411 {
34412 PyThreadState* __tstate = wxPyBeginAllowThreads();
34413 (arg1)->SetTitle((wxString const &)*arg2);
34414
34415 wxPyEndAllowThreads(__tstate);
34416 if (PyErr_Occurred()) SWIG_fail;
34417 }
34418 Py_INCREF(Py_None); resultobj = Py_None;
34419 {
34420 if (temp2)
34421 delete arg2;
34422 }
34423 return resultobj;
34424 fail:
34425 {
34426 if (temp2)
34427 delete arg2;
34428 }
34429 return NULL;
34430 }
34431
34432
34433 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34434 PyObject *resultobj;
34435 wxMenu *arg1 = (wxMenu *) 0 ;
34436 wxString result;
34437 PyObject * obj0 = 0 ;
34438 char *kwnames[] = {
34439 (char *) "self", NULL
34440 };
34441
34442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34444 if (SWIG_arg_fail(1)) SWIG_fail;
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 result = ((wxMenu const *)arg1)->GetTitle();
34448
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 {
34453 #if wxUSE_UNICODE
34454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34455 #else
34456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34457 #endif
34458 }
34459 return resultobj;
34460 fail:
34461 return NULL;
34462 }
34463
34464
34465 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34466 PyObject *resultobj;
34467 wxMenu *arg1 = (wxMenu *) 0 ;
34468 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34469 PyObject * obj0 = 0 ;
34470 PyObject * obj1 = 0 ;
34471 char *kwnames[] = {
34472 (char *) "self",(char *) "handler", NULL
34473 };
34474
34475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34477 if (SWIG_arg_fail(1)) SWIG_fail;
34478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34479 if (SWIG_arg_fail(2)) SWIG_fail;
34480 {
34481 PyThreadState* __tstate = wxPyBeginAllowThreads();
34482 (arg1)->SetEventHandler(arg2);
34483
34484 wxPyEndAllowThreads(__tstate);
34485 if (PyErr_Occurred()) SWIG_fail;
34486 }
34487 Py_INCREF(Py_None); resultobj = Py_None;
34488 return resultobj;
34489 fail:
34490 return NULL;
34491 }
34492
34493
34494 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34495 PyObject *resultobj;
34496 wxMenu *arg1 = (wxMenu *) 0 ;
34497 wxEvtHandler *result;
34498 PyObject * obj0 = 0 ;
34499 char *kwnames[] = {
34500 (char *) "self", NULL
34501 };
34502
34503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34505 if (SWIG_arg_fail(1)) SWIG_fail;
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34509
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 {
34514 resultobj = wxPyMake_wxObject(result, 0);
34515 }
34516 return resultobj;
34517 fail:
34518 return NULL;
34519 }
34520
34521
34522 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34523 PyObject *resultobj;
34524 wxMenu *arg1 = (wxMenu *) 0 ;
34525 wxWindow *arg2 = (wxWindow *) 0 ;
34526 PyObject * obj0 = 0 ;
34527 PyObject * obj1 = 0 ;
34528 char *kwnames[] = {
34529 (char *) "self",(char *) "win", NULL
34530 };
34531
34532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34534 if (SWIG_arg_fail(1)) SWIG_fail;
34535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34536 if (SWIG_arg_fail(2)) SWIG_fail;
34537 {
34538 PyThreadState* __tstate = wxPyBeginAllowThreads();
34539 (arg1)->SetInvokingWindow(arg2);
34540
34541 wxPyEndAllowThreads(__tstate);
34542 if (PyErr_Occurred()) SWIG_fail;
34543 }
34544 Py_INCREF(Py_None); resultobj = Py_None;
34545 return resultobj;
34546 fail:
34547 return NULL;
34548 }
34549
34550
34551 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34552 PyObject *resultobj;
34553 wxMenu *arg1 = (wxMenu *) 0 ;
34554 wxWindow *result;
34555 PyObject * obj0 = 0 ;
34556 char *kwnames[] = {
34557 (char *) "self", NULL
34558 };
34559
34560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34562 if (SWIG_arg_fail(1)) SWIG_fail;
34563 {
34564 PyThreadState* __tstate = wxPyBeginAllowThreads();
34565 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34566
34567 wxPyEndAllowThreads(__tstate);
34568 if (PyErr_Occurred()) SWIG_fail;
34569 }
34570 {
34571 resultobj = wxPyMake_wxObject(result, 0);
34572 }
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34580 PyObject *resultobj;
34581 wxMenu *arg1 = (wxMenu *) 0 ;
34582 long result;
34583 PyObject * obj0 = 0 ;
34584 char *kwnames[] = {
34585 (char *) "self", NULL
34586 };
34587
34588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34590 if (SWIG_arg_fail(1)) SWIG_fail;
34591 {
34592 PyThreadState* __tstate = wxPyBeginAllowThreads();
34593 result = (long)((wxMenu const *)arg1)->GetStyle();
34594
34595 wxPyEndAllowThreads(__tstate);
34596 if (PyErr_Occurred()) SWIG_fail;
34597 }
34598 {
34599 resultobj = SWIG_From_long((long)(result));
34600 }
34601 return resultobj;
34602 fail:
34603 return NULL;
34604 }
34605
34606
34607 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34608 PyObject *resultobj;
34609 wxMenu *arg1 = (wxMenu *) 0 ;
34610 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34611 PyObject * obj0 = 0 ;
34612 PyObject * obj1 = 0 ;
34613 char *kwnames[] = {
34614 (char *) "self",(char *) "source", NULL
34615 };
34616
34617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34619 if (SWIG_arg_fail(1)) SWIG_fail;
34620 if (obj1) {
34621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34622 if (SWIG_arg_fail(2)) SWIG_fail;
34623 }
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 (arg1)->UpdateUI(arg2);
34627
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 Py_INCREF(Py_None); resultobj = Py_None;
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj;
34640 wxMenu *arg1 = (wxMenu *) 0 ;
34641 wxMenuBar *result;
34642 PyObject * obj0 = 0 ;
34643 char *kwnames[] = {
34644 (char *) "self", NULL
34645 };
34646
34647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34649 if (SWIG_arg_fail(1)) SWIG_fail;
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34653
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 {
34658 resultobj = wxPyMake_wxObject(result, 0);
34659 }
34660 return resultobj;
34661 fail:
34662 return NULL;
34663 }
34664
34665
34666 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34667 PyObject *resultobj;
34668 wxMenu *arg1 = (wxMenu *) 0 ;
34669 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34670 PyObject * obj0 = 0 ;
34671 PyObject * obj1 = 0 ;
34672 char *kwnames[] = {
34673 (char *) "self",(char *) "menubar", NULL
34674 };
34675
34676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34678 if (SWIG_arg_fail(1)) SWIG_fail;
34679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34680 if (SWIG_arg_fail(2)) SWIG_fail;
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 (arg1)->Attach(arg2);
34684
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 Py_INCREF(Py_None); resultobj = Py_None;
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj;
34697 wxMenu *arg1 = (wxMenu *) 0 ;
34698 PyObject * obj0 = 0 ;
34699 char *kwnames[] = {
34700 (char *) "self", NULL
34701 };
34702
34703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34705 if (SWIG_arg_fail(1)) SWIG_fail;
34706 {
34707 PyThreadState* __tstate = wxPyBeginAllowThreads();
34708 (arg1)->Detach();
34709
34710 wxPyEndAllowThreads(__tstate);
34711 if (PyErr_Occurred()) SWIG_fail;
34712 }
34713 Py_INCREF(Py_None); resultobj = Py_None;
34714 return resultobj;
34715 fail:
34716 return NULL;
34717 }
34718
34719
34720 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34721 PyObject *resultobj;
34722 wxMenu *arg1 = (wxMenu *) 0 ;
34723 bool result;
34724 PyObject * obj0 = 0 ;
34725 char *kwnames[] = {
34726 (char *) "self", NULL
34727 };
34728
34729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34731 if (SWIG_arg_fail(1)) SWIG_fail;
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 result = (bool)((wxMenu const *)arg1)->IsAttached();
34735
34736 wxPyEndAllowThreads(__tstate);
34737 if (PyErr_Occurred()) SWIG_fail;
34738 }
34739 {
34740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34741 }
34742 return resultobj;
34743 fail:
34744 return NULL;
34745 }
34746
34747
34748 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34749 PyObject *resultobj;
34750 wxMenu *arg1 = (wxMenu *) 0 ;
34751 wxMenu *arg2 = (wxMenu *) 0 ;
34752 PyObject * obj0 = 0 ;
34753 PyObject * obj1 = 0 ;
34754 char *kwnames[] = {
34755 (char *) "self",(char *) "parent", NULL
34756 };
34757
34758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34760 if (SWIG_arg_fail(1)) SWIG_fail;
34761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34762 if (SWIG_arg_fail(2)) SWIG_fail;
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 (arg1)->SetParent(arg2);
34766
34767 wxPyEndAllowThreads(__tstate);
34768 if (PyErr_Occurred()) SWIG_fail;
34769 }
34770 Py_INCREF(Py_None); resultobj = Py_None;
34771 return resultobj;
34772 fail:
34773 return NULL;
34774 }
34775
34776
34777 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34778 PyObject *resultobj;
34779 wxMenu *arg1 = (wxMenu *) 0 ;
34780 wxMenu *result;
34781 PyObject * obj0 = 0 ;
34782 char *kwnames[] = {
34783 (char *) "self", NULL
34784 };
34785
34786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34788 if (SWIG_arg_fail(1)) SWIG_fail;
34789 {
34790 PyThreadState* __tstate = wxPyBeginAllowThreads();
34791 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34792
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 {
34797 resultobj = wxPyMake_wxObject(result, 0);
34798 }
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34806 PyObject *obj;
34807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34808 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34809 Py_INCREF(obj);
34810 return Py_BuildValue((char *)"");
34811 }
34812 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34813 PyObject *resultobj;
34814 long arg1 = (long) 0 ;
34815 wxMenuBar *result;
34816 PyObject * obj0 = 0 ;
34817 char *kwnames[] = {
34818 (char *) "style", NULL
34819 };
34820
34821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34822 if (obj0) {
34823 {
34824 arg1 = (long)(SWIG_As_long(obj0));
34825 if (SWIG_arg_fail(1)) SWIG_fail;
34826 }
34827 }
34828 {
34829 if (!wxPyCheckForApp()) SWIG_fail;
34830 PyThreadState* __tstate = wxPyBeginAllowThreads();
34831 result = (wxMenuBar *)new wxMenuBar(arg1);
34832
34833 wxPyEndAllowThreads(__tstate);
34834 if (PyErr_Occurred()) SWIG_fail;
34835 }
34836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34837 return resultobj;
34838 fail:
34839 return NULL;
34840 }
34841
34842
34843 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34844 PyObject *resultobj;
34845 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34846 wxMenu *arg2 = (wxMenu *) 0 ;
34847 wxString *arg3 = 0 ;
34848 bool result;
34849 bool temp3 = false ;
34850 PyObject * obj0 = 0 ;
34851 PyObject * obj1 = 0 ;
34852 PyObject * obj2 = 0 ;
34853 char *kwnames[] = {
34854 (char *) "self",(char *) "menu",(char *) "title", NULL
34855 };
34856
34857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34859 if (SWIG_arg_fail(1)) SWIG_fail;
34860 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34861 if (SWIG_arg_fail(2)) SWIG_fail;
34862 {
34863 arg3 = wxString_in_helper(obj2);
34864 if (arg3 == NULL) SWIG_fail;
34865 temp3 = true;
34866 }
34867 {
34868 PyThreadState* __tstate = wxPyBeginAllowThreads();
34869 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34870
34871 wxPyEndAllowThreads(__tstate);
34872 if (PyErr_Occurred()) SWIG_fail;
34873 }
34874 {
34875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34876 }
34877 {
34878 if (temp3)
34879 delete arg3;
34880 }
34881 return resultobj;
34882 fail:
34883 {
34884 if (temp3)
34885 delete arg3;
34886 }
34887 return NULL;
34888 }
34889
34890
34891 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj;
34893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34894 size_t arg2 ;
34895 wxMenu *arg3 = (wxMenu *) 0 ;
34896 wxString *arg4 = 0 ;
34897 bool result;
34898 bool temp4 = false ;
34899 PyObject * obj0 = 0 ;
34900 PyObject * obj1 = 0 ;
34901 PyObject * obj2 = 0 ;
34902 PyObject * obj3 = 0 ;
34903 char *kwnames[] = {
34904 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34905 };
34906
34907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34909 if (SWIG_arg_fail(1)) SWIG_fail;
34910 {
34911 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34912 if (SWIG_arg_fail(2)) SWIG_fail;
34913 }
34914 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34915 if (SWIG_arg_fail(3)) SWIG_fail;
34916 {
34917 arg4 = wxString_in_helper(obj3);
34918 if (arg4 == NULL) SWIG_fail;
34919 temp4 = true;
34920 }
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34924
34925 wxPyEndAllowThreads(__tstate);
34926 if (PyErr_Occurred()) SWIG_fail;
34927 }
34928 {
34929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34930 }
34931 {
34932 if (temp4)
34933 delete arg4;
34934 }
34935 return resultobj;
34936 fail:
34937 {
34938 if (temp4)
34939 delete arg4;
34940 }
34941 return NULL;
34942 }
34943
34944
34945 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34946 PyObject *resultobj;
34947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34948 size_t result;
34949 PyObject * obj0 = 0 ;
34950 char *kwnames[] = {
34951 (char *) "self", NULL
34952 };
34953
34954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34956 if (SWIG_arg_fail(1)) SWIG_fail;
34957 {
34958 PyThreadState* __tstate = wxPyBeginAllowThreads();
34959 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34960
34961 wxPyEndAllowThreads(__tstate);
34962 if (PyErr_Occurred()) SWIG_fail;
34963 }
34964 {
34965 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34966 }
34967 return resultobj;
34968 fail:
34969 return NULL;
34970 }
34971
34972
34973 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34974 PyObject *resultobj;
34975 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34976 size_t arg2 ;
34977 wxMenu *result;
34978 PyObject * obj0 = 0 ;
34979 PyObject * obj1 = 0 ;
34980 char *kwnames[] = {
34981 (char *) "self",(char *) "pos", NULL
34982 };
34983
34984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34986 if (SWIG_arg_fail(1)) SWIG_fail;
34987 {
34988 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34989 if (SWIG_arg_fail(2)) SWIG_fail;
34990 }
34991 {
34992 PyThreadState* __tstate = wxPyBeginAllowThreads();
34993 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34994
34995 wxPyEndAllowThreads(__tstate);
34996 if (PyErr_Occurred()) SWIG_fail;
34997 }
34998 {
34999 resultobj = wxPyMake_wxObject(result, 0);
35000 }
35001 return resultobj;
35002 fail:
35003 return NULL;
35004 }
35005
35006
35007 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35008 PyObject *resultobj;
35009 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35010 size_t arg2 ;
35011 wxMenu *arg3 = (wxMenu *) 0 ;
35012 wxString *arg4 = 0 ;
35013 wxMenu *result;
35014 bool temp4 = false ;
35015 PyObject * obj0 = 0 ;
35016 PyObject * obj1 = 0 ;
35017 PyObject * obj2 = 0 ;
35018 PyObject * obj3 = 0 ;
35019 char *kwnames[] = {
35020 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35021 };
35022
35023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35025 if (SWIG_arg_fail(1)) SWIG_fail;
35026 {
35027 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35028 if (SWIG_arg_fail(2)) SWIG_fail;
35029 }
35030 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35031 if (SWIG_arg_fail(3)) SWIG_fail;
35032 {
35033 arg4 = wxString_in_helper(obj3);
35034 if (arg4 == NULL) SWIG_fail;
35035 temp4 = true;
35036 }
35037 {
35038 PyThreadState* __tstate = wxPyBeginAllowThreads();
35039 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35040
35041 wxPyEndAllowThreads(__tstate);
35042 if (PyErr_Occurred()) SWIG_fail;
35043 }
35044 {
35045 resultobj = wxPyMake_wxObject(result, 0);
35046 }
35047 {
35048 if (temp4)
35049 delete arg4;
35050 }
35051 return resultobj;
35052 fail:
35053 {
35054 if (temp4)
35055 delete arg4;
35056 }
35057 return NULL;
35058 }
35059
35060
35061 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35062 PyObject *resultobj;
35063 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35064 size_t arg2 ;
35065 wxMenu *result;
35066 PyObject * obj0 = 0 ;
35067 PyObject * obj1 = 0 ;
35068 char *kwnames[] = {
35069 (char *) "self",(char *) "pos", NULL
35070 };
35071
35072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35074 if (SWIG_arg_fail(1)) SWIG_fail;
35075 {
35076 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35077 if (SWIG_arg_fail(2)) SWIG_fail;
35078 }
35079 {
35080 PyThreadState* __tstate = wxPyBeginAllowThreads();
35081 result = (wxMenu *)(arg1)->Remove(arg2);
35082
35083 wxPyEndAllowThreads(__tstate);
35084 if (PyErr_Occurred()) SWIG_fail;
35085 }
35086 {
35087 resultobj = wxPyMake_wxObject(result, 0);
35088 }
35089 return resultobj;
35090 fail:
35091 return NULL;
35092 }
35093
35094
35095 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35096 PyObject *resultobj;
35097 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35098 size_t arg2 ;
35099 bool arg3 ;
35100 PyObject * obj0 = 0 ;
35101 PyObject * obj1 = 0 ;
35102 PyObject * obj2 = 0 ;
35103 char *kwnames[] = {
35104 (char *) "self",(char *) "pos",(char *) "enable", NULL
35105 };
35106
35107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35109 if (SWIG_arg_fail(1)) SWIG_fail;
35110 {
35111 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35112 if (SWIG_arg_fail(2)) SWIG_fail;
35113 }
35114 {
35115 arg3 = (bool)(SWIG_As_bool(obj2));
35116 if (SWIG_arg_fail(3)) SWIG_fail;
35117 }
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 (arg1)->EnableTop(arg2,arg3);
35121
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 Py_INCREF(Py_None); resultobj = Py_None;
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35133 PyObject *resultobj;
35134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35135 size_t arg2 ;
35136 bool result;
35137 PyObject * obj0 = 0 ;
35138 PyObject * obj1 = 0 ;
35139 char *kwnames[] = {
35140 (char *) "self",(char *) "pos", NULL
35141 };
35142
35143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35145 if (SWIG_arg_fail(1)) SWIG_fail;
35146 {
35147 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35148 if (SWIG_arg_fail(2)) SWIG_fail;
35149 }
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35153
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 {
35158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35159 }
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35167 PyObject *resultobj;
35168 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35169 size_t arg2 ;
35170 wxString *arg3 = 0 ;
35171 bool temp3 = false ;
35172 PyObject * obj0 = 0 ;
35173 PyObject * obj1 = 0 ;
35174 PyObject * obj2 = 0 ;
35175 char *kwnames[] = {
35176 (char *) "self",(char *) "pos",(char *) "label", NULL
35177 };
35178
35179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35181 if (SWIG_arg_fail(1)) SWIG_fail;
35182 {
35183 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35184 if (SWIG_arg_fail(2)) SWIG_fail;
35185 }
35186 {
35187 arg3 = wxString_in_helper(obj2);
35188 if (arg3 == NULL) SWIG_fail;
35189 temp3 = true;
35190 }
35191 {
35192 PyThreadState* __tstate = wxPyBeginAllowThreads();
35193 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35194
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 Py_INCREF(Py_None); resultobj = Py_None;
35199 {
35200 if (temp3)
35201 delete arg3;
35202 }
35203 return resultobj;
35204 fail:
35205 {
35206 if (temp3)
35207 delete arg3;
35208 }
35209 return NULL;
35210 }
35211
35212
35213 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35214 PyObject *resultobj;
35215 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35216 size_t arg2 ;
35217 wxString result;
35218 PyObject * obj0 = 0 ;
35219 PyObject * obj1 = 0 ;
35220 char *kwnames[] = {
35221 (char *) "self",(char *) "pos", NULL
35222 };
35223
35224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35226 if (SWIG_arg_fail(1)) SWIG_fail;
35227 {
35228 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35229 if (SWIG_arg_fail(2)) SWIG_fail;
35230 }
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35234
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 {
35239 #if wxUSE_UNICODE
35240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35241 #else
35242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35243 #endif
35244 }
35245 return resultobj;
35246 fail:
35247 return NULL;
35248 }
35249
35250
35251 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35252 PyObject *resultobj;
35253 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35254 wxString *arg2 = 0 ;
35255 wxString *arg3 = 0 ;
35256 int result;
35257 bool temp2 = false ;
35258 bool temp3 = false ;
35259 PyObject * obj0 = 0 ;
35260 PyObject * obj1 = 0 ;
35261 PyObject * obj2 = 0 ;
35262 char *kwnames[] = {
35263 (char *) "self",(char *) "menu",(char *) "item", NULL
35264 };
35265
35266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35268 if (SWIG_arg_fail(1)) SWIG_fail;
35269 {
35270 arg2 = wxString_in_helper(obj1);
35271 if (arg2 == NULL) SWIG_fail;
35272 temp2 = true;
35273 }
35274 {
35275 arg3 = wxString_in_helper(obj2);
35276 if (arg3 == NULL) SWIG_fail;
35277 temp3 = true;
35278 }
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35282
35283 wxPyEndAllowThreads(__tstate);
35284 if (PyErr_Occurred()) SWIG_fail;
35285 }
35286 {
35287 resultobj = SWIG_From_int((int)(result));
35288 }
35289 {
35290 if (temp2)
35291 delete arg2;
35292 }
35293 {
35294 if (temp3)
35295 delete arg3;
35296 }
35297 return resultobj;
35298 fail:
35299 {
35300 if (temp2)
35301 delete arg2;
35302 }
35303 {
35304 if (temp3)
35305 delete arg3;
35306 }
35307 return NULL;
35308 }
35309
35310
35311 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35312 PyObject *resultobj;
35313 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35314 int arg2 ;
35315 wxMenuItem *result;
35316 PyObject * obj0 = 0 ;
35317 PyObject * obj1 = 0 ;
35318 char *kwnames[] = {
35319 (char *) "self",(char *) "id", NULL
35320 };
35321
35322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35324 if (SWIG_arg_fail(1)) SWIG_fail;
35325 {
35326 arg2 = (int)(SWIG_As_int(obj1));
35327 if (SWIG_arg_fail(2)) SWIG_fail;
35328 }
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35332
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 {
35337 resultobj = wxPyMake_wxObject(result, 0);
35338 }
35339 return resultobj;
35340 fail:
35341 return NULL;
35342 }
35343
35344
35345 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35346 PyObject *resultobj;
35347 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35348 wxString *arg2 = 0 ;
35349 int result;
35350 bool temp2 = false ;
35351 PyObject * obj0 = 0 ;
35352 PyObject * obj1 = 0 ;
35353 char *kwnames[] = {
35354 (char *) "self",(char *) "title", NULL
35355 };
35356
35357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35359 if (SWIG_arg_fail(1)) SWIG_fail;
35360 {
35361 arg2 = wxString_in_helper(obj1);
35362 if (arg2 == NULL) SWIG_fail;
35363 temp2 = true;
35364 }
35365 {
35366 PyThreadState* __tstate = wxPyBeginAllowThreads();
35367 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35368
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 {
35373 resultobj = SWIG_From_int((int)(result));
35374 }
35375 {
35376 if (temp2)
35377 delete arg2;
35378 }
35379 return resultobj;
35380 fail:
35381 {
35382 if (temp2)
35383 delete arg2;
35384 }
35385 return NULL;
35386 }
35387
35388
35389 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35390 PyObject *resultobj;
35391 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35392 int arg2 ;
35393 bool arg3 ;
35394 PyObject * obj0 = 0 ;
35395 PyObject * obj1 = 0 ;
35396 PyObject * obj2 = 0 ;
35397 char *kwnames[] = {
35398 (char *) "self",(char *) "id",(char *) "enable", NULL
35399 };
35400
35401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35403 if (SWIG_arg_fail(1)) SWIG_fail;
35404 {
35405 arg2 = (int)(SWIG_As_int(obj1));
35406 if (SWIG_arg_fail(2)) SWIG_fail;
35407 }
35408 {
35409 arg3 = (bool)(SWIG_As_bool(obj2));
35410 if (SWIG_arg_fail(3)) SWIG_fail;
35411 }
35412 {
35413 PyThreadState* __tstate = wxPyBeginAllowThreads();
35414 (arg1)->Enable(arg2,arg3);
35415
35416 wxPyEndAllowThreads(__tstate);
35417 if (PyErr_Occurred()) SWIG_fail;
35418 }
35419 Py_INCREF(Py_None); resultobj = Py_None;
35420 return resultobj;
35421 fail:
35422 return NULL;
35423 }
35424
35425
35426 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35427 PyObject *resultobj;
35428 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35429 int arg2 ;
35430 bool arg3 ;
35431 PyObject * obj0 = 0 ;
35432 PyObject * obj1 = 0 ;
35433 PyObject * obj2 = 0 ;
35434 char *kwnames[] = {
35435 (char *) "self",(char *) "id",(char *) "check", NULL
35436 };
35437
35438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35440 if (SWIG_arg_fail(1)) SWIG_fail;
35441 {
35442 arg2 = (int)(SWIG_As_int(obj1));
35443 if (SWIG_arg_fail(2)) SWIG_fail;
35444 }
35445 {
35446 arg3 = (bool)(SWIG_As_bool(obj2));
35447 if (SWIG_arg_fail(3)) SWIG_fail;
35448 }
35449 {
35450 PyThreadState* __tstate = wxPyBeginAllowThreads();
35451 (arg1)->Check(arg2,arg3);
35452
35453 wxPyEndAllowThreads(__tstate);
35454 if (PyErr_Occurred()) SWIG_fail;
35455 }
35456 Py_INCREF(Py_None); resultobj = Py_None;
35457 return resultobj;
35458 fail:
35459 return NULL;
35460 }
35461
35462
35463 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35464 PyObject *resultobj;
35465 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35466 int arg2 ;
35467 bool result;
35468 PyObject * obj0 = 0 ;
35469 PyObject * obj1 = 0 ;
35470 char *kwnames[] = {
35471 (char *) "self",(char *) "id", NULL
35472 };
35473
35474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35476 if (SWIG_arg_fail(1)) SWIG_fail;
35477 {
35478 arg2 = (int)(SWIG_As_int(obj1));
35479 if (SWIG_arg_fail(2)) SWIG_fail;
35480 }
35481 {
35482 PyThreadState* __tstate = wxPyBeginAllowThreads();
35483 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35484
35485 wxPyEndAllowThreads(__tstate);
35486 if (PyErr_Occurred()) SWIG_fail;
35487 }
35488 {
35489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35490 }
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35498 PyObject *resultobj;
35499 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35500 int arg2 ;
35501 bool result;
35502 PyObject * obj0 = 0 ;
35503 PyObject * obj1 = 0 ;
35504 char *kwnames[] = {
35505 (char *) "self",(char *) "id", NULL
35506 };
35507
35508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35510 if (SWIG_arg_fail(1)) SWIG_fail;
35511 {
35512 arg2 = (int)(SWIG_As_int(obj1));
35513 if (SWIG_arg_fail(2)) SWIG_fail;
35514 }
35515 {
35516 PyThreadState* __tstate = wxPyBeginAllowThreads();
35517 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35518
35519 wxPyEndAllowThreads(__tstate);
35520 if (PyErr_Occurred()) SWIG_fail;
35521 }
35522 {
35523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj;
35533 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35534 int arg2 ;
35535 wxString *arg3 = 0 ;
35536 bool temp3 = false ;
35537 PyObject * obj0 = 0 ;
35538 PyObject * obj1 = 0 ;
35539 PyObject * obj2 = 0 ;
35540 char *kwnames[] = {
35541 (char *) "self",(char *) "id",(char *) "label", NULL
35542 };
35543
35544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35546 if (SWIG_arg_fail(1)) SWIG_fail;
35547 {
35548 arg2 = (int)(SWIG_As_int(obj1));
35549 if (SWIG_arg_fail(2)) SWIG_fail;
35550 }
35551 {
35552 arg3 = wxString_in_helper(obj2);
35553 if (arg3 == NULL) SWIG_fail;
35554 temp3 = true;
35555 }
35556 {
35557 PyThreadState* __tstate = wxPyBeginAllowThreads();
35558 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35559
35560 wxPyEndAllowThreads(__tstate);
35561 if (PyErr_Occurred()) SWIG_fail;
35562 }
35563 Py_INCREF(Py_None); resultobj = Py_None;
35564 {
35565 if (temp3)
35566 delete arg3;
35567 }
35568 return resultobj;
35569 fail:
35570 {
35571 if (temp3)
35572 delete arg3;
35573 }
35574 return NULL;
35575 }
35576
35577
35578 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35579 PyObject *resultobj;
35580 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35581 int arg2 ;
35582 wxString result;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 char *kwnames[] = {
35586 (char *) "self",(char *) "id", NULL
35587 };
35588
35589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35591 if (SWIG_arg_fail(1)) SWIG_fail;
35592 {
35593 arg2 = (int)(SWIG_As_int(obj1));
35594 if (SWIG_arg_fail(2)) SWIG_fail;
35595 }
35596 {
35597 PyThreadState* __tstate = wxPyBeginAllowThreads();
35598 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35599
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 {
35604 #if wxUSE_UNICODE
35605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35606 #else
35607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35608 #endif
35609 }
35610 return resultobj;
35611 fail:
35612 return NULL;
35613 }
35614
35615
35616 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35617 PyObject *resultobj;
35618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35619 int arg2 ;
35620 wxString *arg3 = 0 ;
35621 bool temp3 = false ;
35622 PyObject * obj0 = 0 ;
35623 PyObject * obj1 = 0 ;
35624 PyObject * obj2 = 0 ;
35625 char *kwnames[] = {
35626 (char *) "self",(char *) "id",(char *) "helpString", NULL
35627 };
35628
35629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35631 if (SWIG_arg_fail(1)) SWIG_fail;
35632 {
35633 arg2 = (int)(SWIG_As_int(obj1));
35634 if (SWIG_arg_fail(2)) SWIG_fail;
35635 }
35636 {
35637 arg3 = wxString_in_helper(obj2);
35638 if (arg3 == NULL) SWIG_fail;
35639 temp3 = true;
35640 }
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35644
35645 wxPyEndAllowThreads(__tstate);
35646 if (PyErr_Occurred()) SWIG_fail;
35647 }
35648 Py_INCREF(Py_None); resultobj = Py_None;
35649 {
35650 if (temp3)
35651 delete arg3;
35652 }
35653 return resultobj;
35654 fail:
35655 {
35656 if (temp3)
35657 delete arg3;
35658 }
35659 return NULL;
35660 }
35661
35662
35663 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35664 PyObject *resultobj;
35665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35666 int arg2 ;
35667 wxString result;
35668 PyObject * obj0 = 0 ;
35669 PyObject * obj1 = 0 ;
35670 char *kwnames[] = {
35671 (char *) "self",(char *) "id", NULL
35672 };
35673
35674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35676 if (SWIG_arg_fail(1)) SWIG_fail;
35677 {
35678 arg2 = (int)(SWIG_As_int(obj1));
35679 if (SWIG_arg_fail(2)) SWIG_fail;
35680 }
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35684
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 {
35689 #if wxUSE_UNICODE
35690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35691 #else
35692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35693 #endif
35694 }
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35702 PyObject *resultobj;
35703 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35704 wxFrame *result;
35705 PyObject * obj0 = 0 ;
35706 char *kwnames[] = {
35707 (char *) "self", NULL
35708 };
35709
35710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35712 if (SWIG_arg_fail(1)) SWIG_fail;
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35716
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 {
35721 resultobj = wxPyMake_wxObject(result, 0);
35722 }
35723 return resultobj;
35724 fail:
35725 return NULL;
35726 }
35727
35728
35729 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35730 PyObject *resultobj;
35731 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35732 bool result;
35733 PyObject * obj0 = 0 ;
35734 char *kwnames[] = {
35735 (char *) "self", NULL
35736 };
35737
35738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35740 if (SWIG_arg_fail(1)) SWIG_fail;
35741 {
35742 PyThreadState* __tstate = wxPyBeginAllowThreads();
35743 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35744
35745 wxPyEndAllowThreads(__tstate);
35746 if (PyErr_Occurred()) SWIG_fail;
35747 }
35748 {
35749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35750 }
35751 return resultobj;
35752 fail:
35753 return NULL;
35754 }
35755
35756
35757 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35758 PyObject *resultobj;
35759 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35760 wxFrame *arg2 = (wxFrame *) 0 ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 char *kwnames[] = {
35764 (char *) "self",(char *) "frame", NULL
35765 };
35766
35767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35769 if (SWIG_arg_fail(1)) SWIG_fail;
35770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35771 if (SWIG_arg_fail(2)) SWIG_fail;
35772 {
35773 PyThreadState* __tstate = wxPyBeginAllowThreads();
35774 (arg1)->Attach(arg2);
35775
35776 wxPyEndAllowThreads(__tstate);
35777 if (PyErr_Occurred()) SWIG_fail;
35778 }
35779 Py_INCREF(Py_None); resultobj = Py_None;
35780 return resultobj;
35781 fail:
35782 return NULL;
35783 }
35784
35785
35786 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35787 PyObject *resultobj;
35788 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35789 PyObject * obj0 = 0 ;
35790 char *kwnames[] = {
35791 (char *) "self", NULL
35792 };
35793
35794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35796 if (SWIG_arg_fail(1)) SWIG_fail;
35797 {
35798 PyThreadState* __tstate = wxPyBeginAllowThreads();
35799 (arg1)->Detach();
35800
35801 wxPyEndAllowThreads(__tstate);
35802 if (PyErr_Occurred()) SWIG_fail;
35803 }
35804 Py_INCREF(Py_None); resultobj = Py_None;
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35812 PyObject *obj;
35813 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35814 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35815 Py_INCREF(obj);
35816 return Py_BuildValue((char *)"");
35817 }
35818 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35819 PyObject *resultobj;
35820 wxMenu *arg1 = (wxMenu *) NULL ;
35821 int arg2 = (int) wxID_ANY ;
35822 wxString const &arg3_defvalue = wxPyEmptyString ;
35823 wxString *arg3 = (wxString *) &arg3_defvalue ;
35824 wxString const &arg4_defvalue = wxPyEmptyString ;
35825 wxString *arg4 = (wxString *) &arg4_defvalue ;
35826 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35827 wxMenu *arg6 = (wxMenu *) NULL ;
35828 wxMenuItem *result;
35829 bool temp3 = false ;
35830 bool temp4 = false ;
35831 PyObject * obj0 = 0 ;
35832 PyObject * obj1 = 0 ;
35833 PyObject * obj2 = 0 ;
35834 PyObject * obj3 = 0 ;
35835 PyObject * obj4 = 0 ;
35836 PyObject * obj5 = 0 ;
35837 char *kwnames[] = {
35838 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35839 };
35840
35841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35842 if (obj0) {
35843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35844 if (SWIG_arg_fail(1)) SWIG_fail;
35845 }
35846 if (obj1) {
35847 {
35848 arg2 = (int)(SWIG_As_int(obj1));
35849 if (SWIG_arg_fail(2)) SWIG_fail;
35850 }
35851 }
35852 if (obj2) {
35853 {
35854 arg3 = wxString_in_helper(obj2);
35855 if (arg3 == NULL) SWIG_fail;
35856 temp3 = true;
35857 }
35858 }
35859 if (obj3) {
35860 {
35861 arg4 = wxString_in_helper(obj3);
35862 if (arg4 == NULL) SWIG_fail;
35863 temp4 = true;
35864 }
35865 }
35866 if (obj4) {
35867 {
35868 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35869 if (SWIG_arg_fail(5)) SWIG_fail;
35870 }
35871 }
35872 if (obj5) {
35873 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35874 if (SWIG_arg_fail(6)) SWIG_fail;
35875 }
35876 {
35877 PyThreadState* __tstate = wxPyBeginAllowThreads();
35878 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35879
35880 wxPyEndAllowThreads(__tstate);
35881 if (PyErr_Occurred()) SWIG_fail;
35882 }
35883 {
35884 resultobj = wxPyMake_wxObject(result, 1);
35885 }
35886 {
35887 if (temp3)
35888 delete arg3;
35889 }
35890 {
35891 if (temp4)
35892 delete arg4;
35893 }
35894 return resultobj;
35895 fail:
35896 {
35897 if (temp3)
35898 delete arg3;
35899 }
35900 {
35901 if (temp4)
35902 delete arg4;
35903 }
35904 return NULL;
35905 }
35906
35907
35908 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35909 PyObject *resultobj;
35910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35911 wxMenu *result;
35912 PyObject * obj0 = 0 ;
35913 char *kwnames[] = {
35914 (char *) "self", NULL
35915 };
35916
35917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35919 if (SWIG_arg_fail(1)) SWIG_fail;
35920 {
35921 PyThreadState* __tstate = wxPyBeginAllowThreads();
35922 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35923
35924 wxPyEndAllowThreads(__tstate);
35925 if (PyErr_Occurred()) SWIG_fail;
35926 }
35927 {
35928 resultobj = wxPyMake_wxObject(result, 0);
35929 }
35930 return resultobj;
35931 fail:
35932 return NULL;
35933 }
35934
35935
35936 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35937 PyObject *resultobj;
35938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35939 wxMenu *arg2 = (wxMenu *) 0 ;
35940 PyObject * obj0 = 0 ;
35941 PyObject * obj1 = 0 ;
35942 char *kwnames[] = {
35943 (char *) "self",(char *) "menu", NULL
35944 };
35945
35946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35948 if (SWIG_arg_fail(1)) SWIG_fail;
35949 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35950 if (SWIG_arg_fail(2)) SWIG_fail;
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 (arg1)->SetMenu(arg2);
35954
35955 wxPyEndAllowThreads(__tstate);
35956 if (PyErr_Occurred()) SWIG_fail;
35957 }
35958 Py_INCREF(Py_None); resultobj = Py_None;
35959 return resultobj;
35960 fail:
35961 return NULL;
35962 }
35963
35964
35965 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35966 PyObject *resultobj;
35967 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35968 int arg2 ;
35969 PyObject * obj0 = 0 ;
35970 PyObject * obj1 = 0 ;
35971 char *kwnames[] = {
35972 (char *) "self",(char *) "id", NULL
35973 };
35974
35975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35977 if (SWIG_arg_fail(1)) SWIG_fail;
35978 {
35979 arg2 = (int)(SWIG_As_int(obj1));
35980 if (SWIG_arg_fail(2)) SWIG_fail;
35981 }
35982 {
35983 PyThreadState* __tstate = wxPyBeginAllowThreads();
35984 (arg1)->SetId(arg2);
35985
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 Py_INCREF(Py_None); resultobj = Py_None;
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35997 PyObject *resultobj;
35998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35999 int result;
36000 PyObject * obj0 = 0 ;
36001 char *kwnames[] = {
36002 (char *) "self", NULL
36003 };
36004
36005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36007 if (SWIG_arg_fail(1)) SWIG_fail;
36008 {
36009 PyThreadState* __tstate = wxPyBeginAllowThreads();
36010 result = (int)((wxMenuItem const *)arg1)->GetId();
36011
36012 wxPyEndAllowThreads(__tstate);
36013 if (PyErr_Occurred()) SWIG_fail;
36014 }
36015 {
36016 resultobj = SWIG_From_int((int)(result));
36017 }
36018 return resultobj;
36019 fail:
36020 return NULL;
36021 }
36022
36023
36024 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36025 PyObject *resultobj;
36026 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36027 bool result;
36028 PyObject * obj0 = 0 ;
36029 char *kwnames[] = {
36030 (char *) "self", NULL
36031 };
36032
36033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36035 if (SWIG_arg_fail(1)) SWIG_fail;
36036 {
36037 PyThreadState* __tstate = wxPyBeginAllowThreads();
36038 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36039
36040 wxPyEndAllowThreads(__tstate);
36041 if (PyErr_Occurred()) SWIG_fail;
36042 }
36043 {
36044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36045 }
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36053 PyObject *resultobj;
36054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36055 wxString *arg2 = 0 ;
36056 bool temp2 = false ;
36057 PyObject * obj0 = 0 ;
36058 PyObject * obj1 = 0 ;
36059 char *kwnames[] = {
36060 (char *) "self",(char *) "str", NULL
36061 };
36062
36063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36065 if (SWIG_arg_fail(1)) SWIG_fail;
36066 {
36067 arg2 = wxString_in_helper(obj1);
36068 if (arg2 == NULL) SWIG_fail;
36069 temp2 = true;
36070 }
36071 {
36072 PyThreadState* __tstate = wxPyBeginAllowThreads();
36073 (arg1)->SetText((wxString const &)*arg2);
36074
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 Py_INCREF(Py_None); resultobj = Py_None;
36079 {
36080 if (temp2)
36081 delete arg2;
36082 }
36083 return resultobj;
36084 fail:
36085 {
36086 if (temp2)
36087 delete arg2;
36088 }
36089 return NULL;
36090 }
36091
36092
36093 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36094 PyObject *resultobj;
36095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36096 wxString result;
36097 PyObject * obj0 = 0 ;
36098 char *kwnames[] = {
36099 (char *) "self", NULL
36100 };
36101
36102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36104 if (SWIG_arg_fail(1)) SWIG_fail;
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 result = ((wxMenuItem const *)arg1)->GetLabel();
36108
36109 wxPyEndAllowThreads(__tstate);
36110 if (PyErr_Occurred()) SWIG_fail;
36111 }
36112 {
36113 #if wxUSE_UNICODE
36114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36115 #else
36116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36117 #endif
36118 }
36119 return resultobj;
36120 fail:
36121 return NULL;
36122 }
36123
36124
36125 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36126 PyObject *resultobj;
36127 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36128 wxString *result;
36129 PyObject * obj0 = 0 ;
36130 char *kwnames[] = {
36131 (char *) "self", NULL
36132 };
36133
36134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36136 if (SWIG_arg_fail(1)) SWIG_fail;
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 {
36140 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36141 result = (wxString *) &_result_ref;
36142 }
36143
36144 wxPyEndAllowThreads(__tstate);
36145 if (PyErr_Occurred()) SWIG_fail;
36146 }
36147 {
36148 #if wxUSE_UNICODE
36149 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36150 #else
36151 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36152 #endif
36153 }
36154 return resultobj;
36155 fail:
36156 return NULL;
36157 }
36158
36159
36160 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36161 PyObject *resultobj;
36162 wxString *arg1 = 0 ;
36163 wxString result;
36164 bool temp1 = false ;
36165 PyObject * obj0 = 0 ;
36166 char *kwnames[] = {
36167 (char *) "text", NULL
36168 };
36169
36170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36171 {
36172 arg1 = wxString_in_helper(obj0);
36173 if (arg1 == NULL) SWIG_fail;
36174 temp1 = true;
36175 }
36176 {
36177 PyThreadState* __tstate = wxPyBeginAllowThreads();
36178 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36179
36180 wxPyEndAllowThreads(__tstate);
36181 if (PyErr_Occurred()) SWIG_fail;
36182 }
36183 {
36184 #if wxUSE_UNICODE
36185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36186 #else
36187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36188 #endif
36189 }
36190 {
36191 if (temp1)
36192 delete arg1;
36193 }
36194 return resultobj;
36195 fail:
36196 {
36197 if (temp1)
36198 delete arg1;
36199 }
36200 return NULL;
36201 }
36202
36203
36204 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36205 PyObject *resultobj;
36206 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36207 wxItemKind result;
36208 PyObject * obj0 = 0 ;
36209 char *kwnames[] = {
36210 (char *) "self", NULL
36211 };
36212
36213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36215 if (SWIG_arg_fail(1)) SWIG_fail;
36216 {
36217 PyThreadState* __tstate = wxPyBeginAllowThreads();
36218 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36219
36220 wxPyEndAllowThreads(__tstate);
36221 if (PyErr_Occurred()) SWIG_fail;
36222 }
36223 resultobj = SWIG_From_int((result));
36224 return resultobj;
36225 fail:
36226 return NULL;
36227 }
36228
36229
36230 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36231 PyObject *resultobj;
36232 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36233 wxItemKind arg2 ;
36234 PyObject * obj0 = 0 ;
36235 PyObject * obj1 = 0 ;
36236 char *kwnames[] = {
36237 (char *) "self",(char *) "kind", NULL
36238 };
36239
36240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36242 if (SWIG_arg_fail(1)) SWIG_fail;
36243 {
36244 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36245 if (SWIG_arg_fail(2)) SWIG_fail;
36246 }
36247 {
36248 PyThreadState* __tstate = wxPyBeginAllowThreads();
36249 (arg1)->SetKind((wxItemKind )arg2);
36250
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 Py_INCREF(Py_None); resultobj = Py_None;
36255 return resultobj;
36256 fail:
36257 return NULL;
36258 }
36259
36260
36261 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36262 PyObject *resultobj;
36263 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36264 bool arg2 ;
36265 PyObject * obj0 = 0 ;
36266 PyObject * obj1 = 0 ;
36267 char *kwnames[] = {
36268 (char *) "self",(char *) "checkable", NULL
36269 };
36270
36271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36273 if (SWIG_arg_fail(1)) SWIG_fail;
36274 {
36275 arg2 = (bool)(SWIG_As_bool(obj1));
36276 if (SWIG_arg_fail(2)) SWIG_fail;
36277 }
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 (arg1)->SetCheckable(arg2);
36281
36282 wxPyEndAllowThreads(__tstate);
36283 if (PyErr_Occurred()) SWIG_fail;
36284 }
36285 Py_INCREF(Py_None); resultobj = Py_None;
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36293 PyObject *resultobj;
36294 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36295 bool result;
36296 PyObject * obj0 = 0 ;
36297 char *kwnames[] = {
36298 (char *) "self", NULL
36299 };
36300
36301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36303 if (SWIG_arg_fail(1)) SWIG_fail;
36304 {
36305 PyThreadState* __tstate = wxPyBeginAllowThreads();
36306 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36307
36308 wxPyEndAllowThreads(__tstate);
36309 if (PyErr_Occurred()) SWIG_fail;
36310 }
36311 {
36312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36313 }
36314 return resultobj;
36315 fail:
36316 return NULL;
36317 }
36318
36319
36320 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36321 PyObject *resultobj;
36322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36323 bool result;
36324 PyObject * obj0 = 0 ;
36325 char *kwnames[] = {
36326 (char *) "self", NULL
36327 };
36328
36329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36331 if (SWIG_arg_fail(1)) SWIG_fail;
36332 {
36333 PyThreadState* __tstate = wxPyBeginAllowThreads();
36334 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36335
36336 wxPyEndAllowThreads(__tstate);
36337 if (PyErr_Occurred()) SWIG_fail;
36338 }
36339 {
36340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36341 }
36342 return resultobj;
36343 fail:
36344 return NULL;
36345 }
36346
36347
36348 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36349 PyObject *resultobj;
36350 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36351 wxMenu *arg2 = (wxMenu *) 0 ;
36352 PyObject * obj0 = 0 ;
36353 PyObject * obj1 = 0 ;
36354 char *kwnames[] = {
36355 (char *) "self",(char *) "menu", NULL
36356 };
36357
36358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36360 if (SWIG_arg_fail(1)) SWIG_fail;
36361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36362 if (SWIG_arg_fail(2)) SWIG_fail;
36363 {
36364 PyThreadState* __tstate = wxPyBeginAllowThreads();
36365 (arg1)->SetSubMenu(arg2);
36366
36367 wxPyEndAllowThreads(__tstate);
36368 if (PyErr_Occurred()) SWIG_fail;
36369 }
36370 Py_INCREF(Py_None); resultobj = Py_None;
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36378 PyObject *resultobj;
36379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36380 wxMenu *result;
36381 PyObject * obj0 = 0 ;
36382 char *kwnames[] = {
36383 (char *) "self", NULL
36384 };
36385
36386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36388 if (SWIG_arg_fail(1)) SWIG_fail;
36389 {
36390 PyThreadState* __tstate = wxPyBeginAllowThreads();
36391 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36392
36393 wxPyEndAllowThreads(__tstate);
36394 if (PyErr_Occurred()) SWIG_fail;
36395 }
36396 {
36397 resultobj = wxPyMake_wxObject(result, 0);
36398 }
36399 return resultobj;
36400 fail:
36401 return NULL;
36402 }
36403
36404
36405 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36406 PyObject *resultobj;
36407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36408 bool arg2 = (bool) true ;
36409 PyObject * obj0 = 0 ;
36410 PyObject * obj1 = 0 ;
36411 char *kwnames[] = {
36412 (char *) "self",(char *) "enable", NULL
36413 };
36414
36415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36417 if (SWIG_arg_fail(1)) SWIG_fail;
36418 if (obj1) {
36419 {
36420 arg2 = (bool)(SWIG_As_bool(obj1));
36421 if (SWIG_arg_fail(2)) SWIG_fail;
36422 }
36423 }
36424 {
36425 PyThreadState* __tstate = wxPyBeginAllowThreads();
36426 (arg1)->Enable(arg2);
36427
36428 wxPyEndAllowThreads(__tstate);
36429 if (PyErr_Occurred()) SWIG_fail;
36430 }
36431 Py_INCREF(Py_None); resultobj = Py_None;
36432 return resultobj;
36433 fail:
36434 return NULL;
36435 }
36436
36437
36438 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36439 PyObject *resultobj;
36440 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36441 bool result;
36442 PyObject * obj0 = 0 ;
36443 char *kwnames[] = {
36444 (char *) "self", NULL
36445 };
36446
36447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36449 if (SWIG_arg_fail(1)) SWIG_fail;
36450 {
36451 PyThreadState* __tstate = wxPyBeginAllowThreads();
36452 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36453
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 {
36458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36459 }
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36467 PyObject *resultobj;
36468 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36469 bool arg2 = (bool) true ;
36470 PyObject * obj0 = 0 ;
36471 PyObject * obj1 = 0 ;
36472 char *kwnames[] = {
36473 (char *) "self",(char *) "check", NULL
36474 };
36475
36476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36478 if (SWIG_arg_fail(1)) SWIG_fail;
36479 if (obj1) {
36480 {
36481 arg2 = (bool)(SWIG_As_bool(obj1));
36482 if (SWIG_arg_fail(2)) SWIG_fail;
36483 }
36484 }
36485 {
36486 PyThreadState* __tstate = wxPyBeginAllowThreads();
36487 (arg1)->Check(arg2);
36488
36489 wxPyEndAllowThreads(__tstate);
36490 if (PyErr_Occurred()) SWIG_fail;
36491 }
36492 Py_INCREF(Py_None); resultobj = Py_None;
36493 return resultobj;
36494 fail:
36495 return NULL;
36496 }
36497
36498
36499 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36500 PyObject *resultobj;
36501 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36502 bool result;
36503 PyObject * obj0 = 0 ;
36504 char *kwnames[] = {
36505 (char *) "self", NULL
36506 };
36507
36508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36510 if (SWIG_arg_fail(1)) SWIG_fail;
36511 {
36512 PyThreadState* __tstate = wxPyBeginAllowThreads();
36513 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36514
36515 wxPyEndAllowThreads(__tstate);
36516 if (PyErr_Occurred()) SWIG_fail;
36517 }
36518 {
36519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36520 }
36521 return resultobj;
36522 fail:
36523 return NULL;
36524 }
36525
36526
36527 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36528 PyObject *resultobj;
36529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36530 PyObject * obj0 = 0 ;
36531 char *kwnames[] = {
36532 (char *) "self", NULL
36533 };
36534
36535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36537 if (SWIG_arg_fail(1)) SWIG_fail;
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 (arg1)->Toggle();
36541
36542 wxPyEndAllowThreads(__tstate);
36543 if (PyErr_Occurred()) SWIG_fail;
36544 }
36545 Py_INCREF(Py_None); resultobj = Py_None;
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj;
36554 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36555 wxString *arg2 = 0 ;
36556 bool temp2 = false ;
36557 PyObject * obj0 = 0 ;
36558 PyObject * obj1 = 0 ;
36559 char *kwnames[] = {
36560 (char *) "self",(char *) "str", NULL
36561 };
36562
36563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36565 if (SWIG_arg_fail(1)) SWIG_fail;
36566 {
36567 arg2 = wxString_in_helper(obj1);
36568 if (arg2 == NULL) SWIG_fail;
36569 temp2 = true;
36570 }
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 (arg1)->SetHelp((wxString const &)*arg2);
36574
36575 wxPyEndAllowThreads(__tstate);
36576 if (PyErr_Occurred()) SWIG_fail;
36577 }
36578 Py_INCREF(Py_None); resultobj = Py_None;
36579 {
36580 if (temp2)
36581 delete arg2;
36582 }
36583 return resultobj;
36584 fail:
36585 {
36586 if (temp2)
36587 delete arg2;
36588 }
36589 return NULL;
36590 }
36591
36592
36593 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36594 PyObject *resultobj;
36595 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36596 wxString *result;
36597 PyObject * obj0 = 0 ;
36598 char *kwnames[] = {
36599 (char *) "self", NULL
36600 };
36601
36602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36604 if (SWIG_arg_fail(1)) SWIG_fail;
36605 {
36606 PyThreadState* __tstate = wxPyBeginAllowThreads();
36607 {
36608 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36609 result = (wxString *) &_result_ref;
36610 }
36611
36612 wxPyEndAllowThreads(__tstate);
36613 if (PyErr_Occurred()) SWIG_fail;
36614 }
36615 {
36616 #if wxUSE_UNICODE
36617 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36618 #else
36619 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36620 #endif
36621 }
36622 return resultobj;
36623 fail:
36624 return NULL;
36625 }
36626
36627
36628 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36629 PyObject *resultobj;
36630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36631 wxAcceleratorEntry *result;
36632 PyObject * obj0 = 0 ;
36633 char *kwnames[] = {
36634 (char *) "self", NULL
36635 };
36636
36637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36639 if (SWIG_arg_fail(1)) SWIG_fail;
36640 {
36641 PyThreadState* __tstate = wxPyBeginAllowThreads();
36642 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36643
36644 wxPyEndAllowThreads(__tstate);
36645 if (PyErr_Occurred()) SWIG_fail;
36646 }
36647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36648 return resultobj;
36649 fail:
36650 return NULL;
36651 }
36652
36653
36654 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36655 PyObject *resultobj;
36656 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36657 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36658 PyObject * obj0 = 0 ;
36659 PyObject * obj1 = 0 ;
36660 char *kwnames[] = {
36661 (char *) "self",(char *) "accel", NULL
36662 };
36663
36664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36666 if (SWIG_arg_fail(1)) SWIG_fail;
36667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36668 if (SWIG_arg_fail(2)) SWIG_fail;
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 (arg1)->SetAccel(arg2);
36672
36673 wxPyEndAllowThreads(__tstate);
36674 if (PyErr_Occurred()) SWIG_fail;
36675 }
36676 Py_INCREF(Py_None); resultobj = Py_None;
36677 return resultobj;
36678 fail:
36679 return NULL;
36680 }
36681
36682
36683 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36684 PyObject *resultobj;
36685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36686 wxFont *arg2 = 0 ;
36687 PyObject * obj0 = 0 ;
36688 PyObject * obj1 = 0 ;
36689 char *kwnames[] = {
36690 (char *) "self",(char *) "font", NULL
36691 };
36692
36693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36695 if (SWIG_arg_fail(1)) SWIG_fail;
36696 {
36697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36698 if (SWIG_arg_fail(2)) SWIG_fail;
36699 if (arg2 == NULL) {
36700 SWIG_null_ref("wxFont");
36701 }
36702 if (SWIG_arg_fail(2)) SWIG_fail;
36703 }
36704 {
36705 PyThreadState* __tstate = wxPyBeginAllowThreads();
36706 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36707
36708 wxPyEndAllowThreads(__tstate);
36709 if (PyErr_Occurred()) SWIG_fail;
36710 }
36711 Py_INCREF(Py_None); resultobj = Py_None;
36712 return resultobj;
36713 fail:
36714 return NULL;
36715 }
36716
36717
36718 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36719 PyObject *resultobj;
36720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36721 wxFont result;
36722 PyObject * obj0 = 0 ;
36723 char *kwnames[] = {
36724 (char *) "self", NULL
36725 };
36726
36727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36729 if (SWIG_arg_fail(1)) SWIG_fail;
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 result = wxMenuItem_GetFont(arg1);
36733
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 {
36738 wxFont * resultptr;
36739 resultptr = new wxFont((wxFont &)(result));
36740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36741 }
36742 return resultobj;
36743 fail:
36744 return NULL;
36745 }
36746
36747
36748 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36749 PyObject *resultobj;
36750 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36751 wxColour *arg2 = 0 ;
36752 wxColour temp2 ;
36753 PyObject * obj0 = 0 ;
36754 PyObject * obj1 = 0 ;
36755 char *kwnames[] = {
36756 (char *) "self",(char *) "colText", NULL
36757 };
36758
36759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36761 if (SWIG_arg_fail(1)) SWIG_fail;
36762 {
36763 arg2 = &temp2;
36764 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36765 }
36766 {
36767 PyThreadState* __tstate = wxPyBeginAllowThreads();
36768 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36769
36770 wxPyEndAllowThreads(__tstate);
36771 if (PyErr_Occurred()) SWIG_fail;
36772 }
36773 Py_INCREF(Py_None); resultobj = Py_None;
36774 return resultobj;
36775 fail:
36776 return NULL;
36777 }
36778
36779
36780 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36781 PyObject *resultobj;
36782 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36783 wxColour result;
36784 PyObject * obj0 = 0 ;
36785 char *kwnames[] = {
36786 (char *) "self", NULL
36787 };
36788
36789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36791 if (SWIG_arg_fail(1)) SWIG_fail;
36792 {
36793 PyThreadState* __tstate = wxPyBeginAllowThreads();
36794 result = wxMenuItem_GetTextColour(arg1);
36795
36796 wxPyEndAllowThreads(__tstate);
36797 if (PyErr_Occurred()) SWIG_fail;
36798 }
36799 {
36800 wxColour * resultptr;
36801 resultptr = new wxColour((wxColour &)(result));
36802 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36803 }
36804 return resultobj;
36805 fail:
36806 return NULL;
36807 }
36808
36809
36810 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36811 PyObject *resultobj;
36812 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36813 wxColour *arg2 = 0 ;
36814 wxColour temp2 ;
36815 PyObject * obj0 = 0 ;
36816 PyObject * obj1 = 0 ;
36817 char *kwnames[] = {
36818 (char *) "self",(char *) "colBack", NULL
36819 };
36820
36821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36823 if (SWIG_arg_fail(1)) SWIG_fail;
36824 {
36825 arg2 = &temp2;
36826 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36827 }
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36831
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 Py_INCREF(Py_None); resultobj = Py_None;
36836 return resultobj;
36837 fail:
36838 return NULL;
36839 }
36840
36841
36842 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36843 PyObject *resultobj;
36844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36845 wxColour result;
36846 PyObject * obj0 = 0 ;
36847 char *kwnames[] = {
36848 (char *) "self", NULL
36849 };
36850
36851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36853 if (SWIG_arg_fail(1)) SWIG_fail;
36854 {
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 result = wxMenuItem_GetBackgroundColour(arg1);
36857
36858 wxPyEndAllowThreads(__tstate);
36859 if (PyErr_Occurred()) SWIG_fail;
36860 }
36861 {
36862 wxColour * resultptr;
36863 resultptr = new wxColour((wxColour &)(result));
36864 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36865 }
36866 return resultobj;
36867 fail:
36868 return NULL;
36869 }
36870
36871
36872 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36873 PyObject *resultobj;
36874 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36875 wxBitmap *arg2 = 0 ;
36876 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36877 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 PyObject * obj2 = 0 ;
36881 char *kwnames[] = {
36882 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36883 };
36884
36885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36887 if (SWIG_arg_fail(1)) SWIG_fail;
36888 {
36889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36890 if (SWIG_arg_fail(2)) SWIG_fail;
36891 if (arg2 == NULL) {
36892 SWIG_null_ref("wxBitmap");
36893 }
36894 if (SWIG_arg_fail(2)) SWIG_fail;
36895 }
36896 if (obj2) {
36897 {
36898 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36899 if (SWIG_arg_fail(3)) SWIG_fail;
36900 if (arg3 == NULL) {
36901 SWIG_null_ref("wxBitmap");
36902 }
36903 if (SWIG_arg_fail(3)) SWIG_fail;
36904 }
36905 }
36906 {
36907 PyThreadState* __tstate = wxPyBeginAllowThreads();
36908 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36909
36910 wxPyEndAllowThreads(__tstate);
36911 if (PyErr_Occurred()) SWIG_fail;
36912 }
36913 Py_INCREF(Py_None); resultobj = Py_None;
36914 return resultobj;
36915 fail:
36916 return NULL;
36917 }
36918
36919
36920 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36921 PyObject *resultobj;
36922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36923 wxBitmap *arg2 = 0 ;
36924 PyObject * obj0 = 0 ;
36925 PyObject * obj1 = 0 ;
36926 char *kwnames[] = {
36927 (char *) "self",(char *) "bmpDisabled", NULL
36928 };
36929
36930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36932 if (SWIG_arg_fail(1)) SWIG_fail;
36933 {
36934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36935 if (SWIG_arg_fail(2)) SWIG_fail;
36936 if (arg2 == NULL) {
36937 SWIG_null_ref("wxBitmap");
36938 }
36939 if (SWIG_arg_fail(2)) SWIG_fail;
36940 }
36941 {
36942 PyThreadState* __tstate = wxPyBeginAllowThreads();
36943 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36944
36945 wxPyEndAllowThreads(__tstate);
36946 if (PyErr_Occurred()) SWIG_fail;
36947 }
36948 Py_INCREF(Py_None); resultobj = Py_None;
36949 return resultobj;
36950 fail:
36951 return NULL;
36952 }
36953
36954
36955 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36956 PyObject *resultobj;
36957 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36958 wxBitmap *result;
36959 PyObject * obj0 = 0 ;
36960 char *kwnames[] = {
36961 (char *) "self", NULL
36962 };
36963
36964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36966 if (SWIG_arg_fail(1)) SWIG_fail;
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 {
36970 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
36971 result = (wxBitmap *) &_result_ref;
36972 }
36973
36974 wxPyEndAllowThreads(__tstate);
36975 if (PyErr_Occurred()) SWIG_fail;
36976 }
36977 {
36978 wxBitmap* resultptr = new wxBitmap(*result);
36979 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36980 }
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36988 PyObject *resultobj;
36989 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36990 int arg2 ;
36991 PyObject * obj0 = 0 ;
36992 PyObject * obj1 = 0 ;
36993 char *kwnames[] = {
36994 (char *) "self",(char *) "nWidth", NULL
36995 };
36996
36997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36999 if (SWIG_arg_fail(1)) SWIG_fail;
37000 {
37001 arg2 = (int)(SWIG_As_int(obj1));
37002 if (SWIG_arg_fail(2)) SWIG_fail;
37003 }
37004 {
37005 PyThreadState* __tstate = wxPyBeginAllowThreads();
37006 wxMenuItem_SetMarginWidth(arg1,arg2);
37007
37008 wxPyEndAllowThreads(__tstate);
37009 if (PyErr_Occurred()) SWIG_fail;
37010 }
37011 Py_INCREF(Py_None); resultobj = Py_None;
37012 return resultobj;
37013 fail:
37014 return NULL;
37015 }
37016
37017
37018 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37019 PyObject *resultobj;
37020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37021 int result;
37022 PyObject * obj0 = 0 ;
37023 char *kwnames[] = {
37024 (char *) "self", NULL
37025 };
37026
37027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37029 if (SWIG_arg_fail(1)) SWIG_fail;
37030 {
37031 PyThreadState* __tstate = wxPyBeginAllowThreads();
37032 result = (int)wxMenuItem_GetMarginWidth(arg1);
37033
37034 wxPyEndAllowThreads(__tstate);
37035 if (PyErr_Occurred()) SWIG_fail;
37036 }
37037 {
37038 resultobj = SWIG_From_int((int)(result));
37039 }
37040 return resultobj;
37041 fail:
37042 return NULL;
37043 }
37044
37045
37046 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37047 PyObject *resultobj;
37048 int result;
37049 char *kwnames[] = {
37050 NULL
37051 };
37052
37053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37054 {
37055 PyThreadState* __tstate = wxPyBeginAllowThreads();
37056 result = (int)MenuItem_GetDefaultMarginWidth();
37057
37058 wxPyEndAllowThreads(__tstate);
37059 if (PyErr_Occurred()) SWIG_fail;
37060 }
37061 {
37062 resultobj = SWIG_From_int((int)(result));
37063 }
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj;
37072 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37073 bool result;
37074 PyObject * obj0 = 0 ;
37075 char *kwnames[] = {
37076 (char *) "self", NULL
37077 };
37078
37079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37081 if (SWIG_arg_fail(1)) SWIG_fail;
37082 {
37083 PyThreadState* __tstate = wxPyBeginAllowThreads();
37084 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37085
37086 wxPyEndAllowThreads(__tstate);
37087 if (PyErr_Occurred()) SWIG_fail;
37088 }
37089 {
37090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37091 }
37092 return resultobj;
37093 fail:
37094 return NULL;
37095 }
37096
37097
37098 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37099 PyObject *resultobj;
37100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37101 bool arg2 = (bool) true ;
37102 PyObject * obj0 = 0 ;
37103 PyObject * obj1 = 0 ;
37104 char *kwnames[] = {
37105 (char *) "self",(char *) "ownerDrawn", NULL
37106 };
37107
37108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37110 if (SWIG_arg_fail(1)) SWIG_fail;
37111 if (obj1) {
37112 {
37113 arg2 = (bool)(SWIG_As_bool(obj1));
37114 if (SWIG_arg_fail(2)) SWIG_fail;
37115 }
37116 }
37117 {
37118 PyThreadState* __tstate = wxPyBeginAllowThreads();
37119 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37120
37121 wxPyEndAllowThreads(__tstate);
37122 if (PyErr_Occurred()) SWIG_fail;
37123 }
37124 Py_INCREF(Py_None); resultobj = Py_None;
37125 return resultobj;
37126 fail:
37127 return NULL;
37128 }
37129
37130
37131 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37132 PyObject *resultobj;
37133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37134 PyObject * obj0 = 0 ;
37135 char *kwnames[] = {
37136 (char *) "self", NULL
37137 };
37138
37139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37141 if (SWIG_arg_fail(1)) SWIG_fail;
37142 {
37143 PyThreadState* __tstate = wxPyBeginAllowThreads();
37144 wxMenuItem_ResetOwnerDrawn(arg1);
37145
37146 wxPyEndAllowThreads(__tstate);
37147 if (PyErr_Occurred()) SWIG_fail;
37148 }
37149 Py_INCREF(Py_None); resultobj = Py_None;
37150 return resultobj;
37151 fail:
37152 return NULL;
37153 }
37154
37155
37156 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37157 PyObject *resultobj;
37158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37159 wxBitmap *arg2 = 0 ;
37160 PyObject * obj0 = 0 ;
37161 PyObject * obj1 = 0 ;
37162 char *kwnames[] = {
37163 (char *) "self",(char *) "bitmap", NULL
37164 };
37165
37166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37168 if (SWIG_arg_fail(1)) SWIG_fail;
37169 {
37170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37171 if (SWIG_arg_fail(2)) SWIG_fail;
37172 if (arg2 == NULL) {
37173 SWIG_null_ref("wxBitmap");
37174 }
37175 if (SWIG_arg_fail(2)) SWIG_fail;
37176 }
37177 {
37178 PyThreadState* __tstate = wxPyBeginAllowThreads();
37179 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37180
37181 wxPyEndAllowThreads(__tstate);
37182 if (PyErr_Occurred()) SWIG_fail;
37183 }
37184 Py_INCREF(Py_None); resultobj = Py_None;
37185 return resultobj;
37186 fail:
37187 return NULL;
37188 }
37189
37190
37191 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37192 PyObject *resultobj;
37193 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37194 wxBitmap *result;
37195 PyObject * obj0 = 0 ;
37196 char *kwnames[] = {
37197 (char *) "self", NULL
37198 };
37199
37200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37202 if (SWIG_arg_fail(1)) SWIG_fail;
37203 {
37204 PyThreadState* __tstate = wxPyBeginAllowThreads();
37205 {
37206 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37207 result = (wxBitmap *) &_result_ref;
37208 }
37209
37210 wxPyEndAllowThreads(__tstate);
37211 if (PyErr_Occurred()) SWIG_fail;
37212 }
37213 {
37214 wxBitmap* resultptr = new wxBitmap(*result);
37215 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37216 }
37217 return resultobj;
37218 fail:
37219 return NULL;
37220 }
37221
37222
37223 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37224 PyObject *obj;
37225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37226 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37227 Py_INCREF(obj);
37228 return Py_BuildValue((char *)"");
37229 }
37230 static int _wrap_ControlNameStr_set(PyObject *) {
37231 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37232 return 1;
37233 }
37234
37235
37236 static PyObject *_wrap_ControlNameStr_get(void) {
37237 PyObject *pyobj;
37238
37239 {
37240 #if wxUSE_UNICODE
37241 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37242 #else
37243 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37244 #endif
37245 }
37246 return pyobj;
37247 }
37248
37249
37250 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37251 PyObject *resultobj;
37252 wxWindow *arg1 = (wxWindow *) 0 ;
37253 int arg2 = (int) -1 ;
37254 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37255 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37256 wxSize const &arg4_defvalue = wxDefaultSize ;
37257 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37258 long arg5 = (long) 0 ;
37259 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37260 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37261 wxString const &arg7_defvalue = wxPyControlNameStr ;
37262 wxString *arg7 = (wxString *) &arg7_defvalue ;
37263 wxControl *result;
37264 wxPoint temp3 ;
37265 wxSize temp4 ;
37266 bool temp7 = false ;
37267 PyObject * obj0 = 0 ;
37268 PyObject * obj1 = 0 ;
37269 PyObject * obj2 = 0 ;
37270 PyObject * obj3 = 0 ;
37271 PyObject * obj4 = 0 ;
37272 PyObject * obj5 = 0 ;
37273 PyObject * obj6 = 0 ;
37274 char *kwnames[] = {
37275 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37276 };
37277
37278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37280 if (SWIG_arg_fail(1)) SWIG_fail;
37281 if (obj1) {
37282 {
37283 arg2 = (int)(SWIG_As_int(obj1));
37284 if (SWIG_arg_fail(2)) SWIG_fail;
37285 }
37286 }
37287 if (obj2) {
37288 {
37289 arg3 = &temp3;
37290 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37291 }
37292 }
37293 if (obj3) {
37294 {
37295 arg4 = &temp4;
37296 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37297 }
37298 }
37299 if (obj4) {
37300 {
37301 arg5 = (long)(SWIG_As_long(obj4));
37302 if (SWIG_arg_fail(5)) SWIG_fail;
37303 }
37304 }
37305 if (obj5) {
37306 {
37307 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37308 if (SWIG_arg_fail(6)) SWIG_fail;
37309 if (arg6 == NULL) {
37310 SWIG_null_ref("wxValidator");
37311 }
37312 if (SWIG_arg_fail(6)) SWIG_fail;
37313 }
37314 }
37315 if (obj6) {
37316 {
37317 arg7 = wxString_in_helper(obj6);
37318 if (arg7 == NULL) SWIG_fail;
37319 temp7 = true;
37320 }
37321 }
37322 {
37323 if (!wxPyCheckForApp()) SWIG_fail;
37324 PyThreadState* __tstate = wxPyBeginAllowThreads();
37325 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37326
37327 wxPyEndAllowThreads(__tstate);
37328 if (PyErr_Occurred()) SWIG_fail;
37329 }
37330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37331 {
37332 if (temp7)
37333 delete arg7;
37334 }
37335 return resultobj;
37336 fail:
37337 {
37338 if (temp7)
37339 delete arg7;
37340 }
37341 return NULL;
37342 }
37343
37344
37345 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37346 PyObject *resultobj;
37347 wxControl *result;
37348 char *kwnames[] = {
37349 NULL
37350 };
37351
37352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37353 {
37354 if (!wxPyCheckForApp()) SWIG_fail;
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 result = (wxControl *)new wxControl();
37357
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37369 PyObject *resultobj;
37370 wxControl *arg1 = (wxControl *) 0 ;
37371 wxWindow *arg2 = (wxWindow *) 0 ;
37372 int arg3 = (int) -1 ;
37373 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37374 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37375 wxSize const &arg5_defvalue = wxDefaultSize ;
37376 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37377 long arg6 = (long) 0 ;
37378 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37379 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37380 wxString const &arg8_defvalue = wxPyControlNameStr ;
37381 wxString *arg8 = (wxString *) &arg8_defvalue ;
37382 bool result;
37383 wxPoint temp4 ;
37384 wxSize temp5 ;
37385 bool temp8 = false ;
37386 PyObject * obj0 = 0 ;
37387 PyObject * obj1 = 0 ;
37388 PyObject * obj2 = 0 ;
37389 PyObject * obj3 = 0 ;
37390 PyObject * obj4 = 0 ;
37391 PyObject * obj5 = 0 ;
37392 PyObject * obj6 = 0 ;
37393 PyObject * obj7 = 0 ;
37394 char *kwnames[] = {
37395 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37396 };
37397
37398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37400 if (SWIG_arg_fail(1)) SWIG_fail;
37401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37402 if (SWIG_arg_fail(2)) SWIG_fail;
37403 if (obj2) {
37404 {
37405 arg3 = (int)(SWIG_As_int(obj2));
37406 if (SWIG_arg_fail(3)) SWIG_fail;
37407 }
37408 }
37409 if (obj3) {
37410 {
37411 arg4 = &temp4;
37412 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37413 }
37414 }
37415 if (obj4) {
37416 {
37417 arg5 = &temp5;
37418 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37419 }
37420 }
37421 if (obj5) {
37422 {
37423 arg6 = (long)(SWIG_As_long(obj5));
37424 if (SWIG_arg_fail(6)) SWIG_fail;
37425 }
37426 }
37427 if (obj6) {
37428 {
37429 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37430 if (SWIG_arg_fail(7)) SWIG_fail;
37431 if (arg7 == NULL) {
37432 SWIG_null_ref("wxValidator");
37433 }
37434 if (SWIG_arg_fail(7)) SWIG_fail;
37435 }
37436 }
37437 if (obj7) {
37438 {
37439 arg8 = wxString_in_helper(obj7);
37440 if (arg8 == NULL) SWIG_fail;
37441 temp8 = true;
37442 }
37443 }
37444 {
37445 PyThreadState* __tstate = wxPyBeginAllowThreads();
37446 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37447
37448 wxPyEndAllowThreads(__tstate);
37449 if (PyErr_Occurred()) SWIG_fail;
37450 }
37451 {
37452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37453 }
37454 {
37455 if (temp8)
37456 delete arg8;
37457 }
37458 return resultobj;
37459 fail:
37460 {
37461 if (temp8)
37462 delete arg8;
37463 }
37464 return NULL;
37465 }
37466
37467
37468 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37469 PyObject *resultobj;
37470 wxControl *arg1 = (wxControl *) 0 ;
37471 wxCommandEvent *arg2 = 0 ;
37472 PyObject * obj0 = 0 ;
37473 PyObject * obj1 = 0 ;
37474 char *kwnames[] = {
37475 (char *) "self",(char *) "event", NULL
37476 };
37477
37478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37480 if (SWIG_arg_fail(1)) SWIG_fail;
37481 {
37482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37483 if (SWIG_arg_fail(2)) SWIG_fail;
37484 if (arg2 == NULL) {
37485 SWIG_null_ref("wxCommandEvent");
37486 }
37487 if (SWIG_arg_fail(2)) SWIG_fail;
37488 }
37489 {
37490 PyThreadState* __tstate = wxPyBeginAllowThreads();
37491 (arg1)->Command(*arg2);
37492
37493 wxPyEndAllowThreads(__tstate);
37494 if (PyErr_Occurred()) SWIG_fail;
37495 }
37496 Py_INCREF(Py_None); resultobj = Py_None;
37497 return resultobj;
37498 fail:
37499 return NULL;
37500 }
37501
37502
37503 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37504 PyObject *resultobj;
37505 wxControl *arg1 = (wxControl *) 0 ;
37506 wxString result;
37507 PyObject * obj0 = 0 ;
37508 char *kwnames[] = {
37509 (char *) "self", NULL
37510 };
37511
37512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37514 if (SWIG_arg_fail(1)) SWIG_fail;
37515 {
37516 PyThreadState* __tstate = wxPyBeginAllowThreads();
37517 result = (arg1)->GetLabel();
37518
37519 wxPyEndAllowThreads(__tstate);
37520 if (PyErr_Occurred()) SWIG_fail;
37521 }
37522 {
37523 #if wxUSE_UNICODE
37524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37525 #else
37526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37527 #endif
37528 }
37529 return resultobj;
37530 fail:
37531 return NULL;
37532 }
37533
37534
37535 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37536 PyObject *resultobj;
37537 wxControl *arg1 = (wxControl *) 0 ;
37538 wxString *arg2 = 0 ;
37539 bool temp2 = false ;
37540 PyObject * obj0 = 0 ;
37541 PyObject * obj1 = 0 ;
37542 char *kwnames[] = {
37543 (char *) "self",(char *) "label", NULL
37544 };
37545
37546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37548 if (SWIG_arg_fail(1)) SWIG_fail;
37549 {
37550 arg2 = wxString_in_helper(obj1);
37551 if (arg2 == NULL) SWIG_fail;
37552 temp2 = true;
37553 }
37554 {
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 (arg1)->SetLabel((wxString const &)*arg2);
37557
37558 wxPyEndAllowThreads(__tstate);
37559 if (PyErr_Occurred()) SWIG_fail;
37560 }
37561 Py_INCREF(Py_None); resultobj = Py_None;
37562 {
37563 if (temp2)
37564 delete arg2;
37565 }
37566 return resultobj;
37567 fail:
37568 {
37569 if (temp2)
37570 delete arg2;
37571 }
37572 return NULL;
37573 }
37574
37575
37576 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37577 PyObject *resultobj;
37578 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37579 wxVisualAttributes result;
37580 PyObject * obj0 = 0 ;
37581 char *kwnames[] = {
37582 (char *) "variant", NULL
37583 };
37584
37585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37586 if (obj0) {
37587 {
37588 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37589 if (SWIG_arg_fail(1)) SWIG_fail;
37590 }
37591 }
37592 {
37593 if (!wxPyCheckForApp()) SWIG_fail;
37594 PyThreadState* __tstate = wxPyBeginAllowThreads();
37595 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37596
37597 wxPyEndAllowThreads(__tstate);
37598 if (PyErr_Occurred()) SWIG_fail;
37599 }
37600 {
37601 wxVisualAttributes * resultptr;
37602 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37604 }
37605 return resultobj;
37606 fail:
37607 return NULL;
37608 }
37609
37610
37611 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37612 PyObject *obj;
37613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37614 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37615 Py_INCREF(obj);
37616 return Py_BuildValue((char *)"");
37617 }
37618 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37619 PyObject *resultobj;
37620 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37621 wxString *arg2 = 0 ;
37622 PyObject *arg3 = (PyObject *) NULL ;
37623 int result;
37624 bool temp2 = false ;
37625 PyObject * obj0 = 0 ;
37626 PyObject * obj1 = 0 ;
37627 PyObject * obj2 = 0 ;
37628 char *kwnames[] = {
37629 (char *) "self",(char *) "item",(char *) "clientData", NULL
37630 };
37631
37632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37634 if (SWIG_arg_fail(1)) SWIG_fail;
37635 {
37636 arg2 = wxString_in_helper(obj1);
37637 if (arg2 == NULL) SWIG_fail;
37638 temp2 = true;
37639 }
37640 if (obj2) {
37641 arg3 = obj2;
37642 }
37643 {
37644 PyThreadState* __tstate = wxPyBeginAllowThreads();
37645 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37646
37647 wxPyEndAllowThreads(__tstate);
37648 if (PyErr_Occurred()) SWIG_fail;
37649 }
37650 {
37651 resultobj = SWIG_From_int((int)(result));
37652 }
37653 {
37654 if (temp2)
37655 delete arg2;
37656 }
37657 return resultobj;
37658 fail:
37659 {
37660 if (temp2)
37661 delete arg2;
37662 }
37663 return NULL;
37664 }
37665
37666
37667 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37668 PyObject *resultobj;
37669 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37670 wxArrayString *arg2 = 0 ;
37671 bool temp2 = false ;
37672 PyObject * obj0 = 0 ;
37673 PyObject * obj1 = 0 ;
37674 char *kwnames[] = {
37675 (char *) "self",(char *) "strings", NULL
37676 };
37677
37678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37680 if (SWIG_arg_fail(1)) SWIG_fail;
37681 {
37682 if (! PySequence_Check(obj1)) {
37683 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37684 SWIG_fail;
37685 }
37686 arg2 = new wxArrayString;
37687 temp2 = true;
37688 int i, len=PySequence_Length(obj1);
37689 for (i=0; i<len; i++) {
37690 PyObject* item = PySequence_GetItem(obj1, i);
37691 #if wxUSE_UNICODE
37692 PyObject* str = PyObject_Unicode(item);
37693 #else
37694 PyObject* str = PyObject_Str(item);
37695 #endif
37696 if (PyErr_Occurred()) SWIG_fail;
37697 arg2->Add(Py2wxString(str));
37698 Py_DECREF(item);
37699 Py_DECREF(str);
37700 }
37701 }
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 (arg1)->Append((wxArrayString const &)*arg2);
37705
37706 wxPyEndAllowThreads(__tstate);
37707 if (PyErr_Occurred()) SWIG_fail;
37708 }
37709 Py_INCREF(Py_None); resultobj = Py_None;
37710 {
37711 if (temp2) delete arg2;
37712 }
37713 return resultobj;
37714 fail:
37715 {
37716 if (temp2) delete arg2;
37717 }
37718 return NULL;
37719 }
37720
37721
37722 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37723 PyObject *resultobj;
37724 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37725 wxString *arg2 = 0 ;
37726 int arg3 ;
37727 PyObject *arg4 = (PyObject *) NULL ;
37728 int result;
37729 bool temp2 = false ;
37730 PyObject * obj0 = 0 ;
37731 PyObject * obj1 = 0 ;
37732 PyObject * obj2 = 0 ;
37733 PyObject * obj3 = 0 ;
37734 char *kwnames[] = {
37735 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37736 };
37737
37738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37740 if (SWIG_arg_fail(1)) SWIG_fail;
37741 {
37742 arg2 = wxString_in_helper(obj1);
37743 if (arg2 == NULL) SWIG_fail;
37744 temp2 = true;
37745 }
37746 {
37747 arg3 = (int)(SWIG_As_int(obj2));
37748 if (SWIG_arg_fail(3)) SWIG_fail;
37749 }
37750 if (obj3) {
37751 arg4 = obj3;
37752 }
37753 {
37754 PyThreadState* __tstate = wxPyBeginAllowThreads();
37755 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37756
37757 wxPyEndAllowThreads(__tstate);
37758 if (PyErr_Occurred()) SWIG_fail;
37759 }
37760 {
37761 resultobj = SWIG_From_int((int)(result));
37762 }
37763 {
37764 if (temp2)
37765 delete arg2;
37766 }
37767 return resultobj;
37768 fail:
37769 {
37770 if (temp2)
37771 delete arg2;
37772 }
37773 return NULL;
37774 }
37775
37776
37777 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37778 PyObject *resultobj;
37779 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37780 PyObject * obj0 = 0 ;
37781 char *kwnames[] = {
37782 (char *) "self", NULL
37783 };
37784
37785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37787 if (SWIG_arg_fail(1)) SWIG_fail;
37788 {
37789 PyThreadState* __tstate = wxPyBeginAllowThreads();
37790 (arg1)->Clear();
37791
37792 wxPyEndAllowThreads(__tstate);
37793 if (PyErr_Occurred()) SWIG_fail;
37794 }
37795 Py_INCREF(Py_None); resultobj = Py_None;
37796 return resultobj;
37797 fail:
37798 return NULL;
37799 }
37800
37801
37802 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37803 PyObject *resultobj;
37804 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37805 int arg2 ;
37806 PyObject * obj0 = 0 ;
37807 PyObject * obj1 = 0 ;
37808 char *kwnames[] = {
37809 (char *) "self",(char *) "n", NULL
37810 };
37811
37812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37814 if (SWIG_arg_fail(1)) SWIG_fail;
37815 {
37816 arg2 = (int)(SWIG_As_int(obj1));
37817 if (SWIG_arg_fail(2)) SWIG_fail;
37818 }
37819 {
37820 PyThreadState* __tstate = wxPyBeginAllowThreads();
37821 (arg1)->Delete(arg2);
37822
37823 wxPyEndAllowThreads(__tstate);
37824 if (PyErr_Occurred()) SWIG_fail;
37825 }
37826 Py_INCREF(Py_None); resultobj = Py_None;
37827 return resultobj;
37828 fail:
37829 return NULL;
37830 }
37831
37832
37833 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37834 PyObject *resultobj;
37835 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37836 int arg2 ;
37837 PyObject *result;
37838 PyObject * obj0 = 0 ;
37839 PyObject * obj1 = 0 ;
37840 char *kwnames[] = {
37841 (char *) "self",(char *) "n", NULL
37842 };
37843
37844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37846 if (SWIG_arg_fail(1)) SWIG_fail;
37847 {
37848 arg2 = (int)(SWIG_As_int(obj1));
37849 if (SWIG_arg_fail(2)) SWIG_fail;
37850 }
37851 {
37852 PyThreadState* __tstate = wxPyBeginAllowThreads();
37853 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37854
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 resultobj = result;
37859 return resultobj;
37860 fail:
37861 return NULL;
37862 }
37863
37864
37865 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37866 PyObject *resultobj;
37867 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37868 int arg2 ;
37869 PyObject *arg3 = (PyObject *) 0 ;
37870 PyObject * obj0 = 0 ;
37871 PyObject * obj1 = 0 ;
37872 PyObject * obj2 = 0 ;
37873 char *kwnames[] = {
37874 (char *) "self",(char *) "n",(char *) "clientData", NULL
37875 };
37876
37877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37879 if (SWIG_arg_fail(1)) SWIG_fail;
37880 {
37881 arg2 = (int)(SWIG_As_int(obj1));
37882 if (SWIG_arg_fail(2)) SWIG_fail;
37883 }
37884 arg3 = obj2;
37885 {
37886 PyThreadState* __tstate = wxPyBeginAllowThreads();
37887 wxItemContainer_SetClientData(arg1,arg2,arg3);
37888
37889 wxPyEndAllowThreads(__tstate);
37890 if (PyErr_Occurred()) SWIG_fail;
37891 }
37892 Py_INCREF(Py_None); resultobj = Py_None;
37893 return resultobj;
37894 fail:
37895 return NULL;
37896 }
37897
37898
37899 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37900 PyObject *resultobj;
37901 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37902 int result;
37903 PyObject * obj0 = 0 ;
37904 char *kwnames[] = {
37905 (char *) "self", NULL
37906 };
37907
37908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37910 if (SWIG_arg_fail(1)) SWIG_fail;
37911 {
37912 PyThreadState* __tstate = wxPyBeginAllowThreads();
37913 result = (int)((wxItemContainer const *)arg1)->GetCount();
37914
37915 wxPyEndAllowThreads(__tstate);
37916 if (PyErr_Occurred()) SWIG_fail;
37917 }
37918 {
37919 resultobj = SWIG_From_int((int)(result));
37920 }
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37928 PyObject *resultobj;
37929 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37930 bool result;
37931 PyObject * obj0 = 0 ;
37932 char *kwnames[] = {
37933 (char *) "self", NULL
37934 };
37935
37936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37938 if (SWIG_arg_fail(1)) SWIG_fail;
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37942
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 {
37947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37948 }
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37956 PyObject *resultobj;
37957 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37958 int arg2 ;
37959 wxString result;
37960 PyObject * obj0 = 0 ;
37961 PyObject * obj1 = 0 ;
37962 char *kwnames[] = {
37963 (char *) "self",(char *) "n", NULL
37964 };
37965
37966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37968 if (SWIG_arg_fail(1)) SWIG_fail;
37969 {
37970 arg2 = (int)(SWIG_As_int(obj1));
37971 if (SWIG_arg_fail(2)) SWIG_fail;
37972 }
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37976
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 {
37981 #if wxUSE_UNICODE
37982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37983 #else
37984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37985 #endif
37986 }
37987 return resultobj;
37988 fail:
37989 return NULL;
37990 }
37991
37992
37993 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37994 PyObject *resultobj;
37995 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37996 wxArrayString result;
37997 PyObject * obj0 = 0 ;
37998 char *kwnames[] = {
37999 (char *) "self", NULL
38000 };
38001
38002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38004 if (SWIG_arg_fail(1)) SWIG_fail;
38005 {
38006 PyThreadState* __tstate = wxPyBeginAllowThreads();
38007 result = ((wxItemContainer const *)arg1)->GetStrings();
38008
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 {
38013 resultobj = wxArrayString2PyList_helper(result);
38014 }
38015 return resultobj;
38016 fail:
38017 return NULL;
38018 }
38019
38020
38021 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38022 PyObject *resultobj;
38023 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38024 int arg2 ;
38025 wxString *arg3 = 0 ;
38026 bool temp3 = false ;
38027 PyObject * obj0 = 0 ;
38028 PyObject * obj1 = 0 ;
38029 PyObject * obj2 = 0 ;
38030 char *kwnames[] = {
38031 (char *) "self",(char *) "n",(char *) "s", NULL
38032 };
38033
38034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38036 if (SWIG_arg_fail(1)) SWIG_fail;
38037 {
38038 arg2 = (int)(SWIG_As_int(obj1));
38039 if (SWIG_arg_fail(2)) SWIG_fail;
38040 }
38041 {
38042 arg3 = wxString_in_helper(obj2);
38043 if (arg3 == NULL) SWIG_fail;
38044 temp3 = true;
38045 }
38046 {
38047 PyThreadState* __tstate = wxPyBeginAllowThreads();
38048 (arg1)->SetString(arg2,(wxString const &)*arg3);
38049
38050 wxPyEndAllowThreads(__tstate);
38051 if (PyErr_Occurred()) SWIG_fail;
38052 }
38053 Py_INCREF(Py_None); resultobj = Py_None;
38054 {
38055 if (temp3)
38056 delete arg3;
38057 }
38058 return resultobj;
38059 fail:
38060 {
38061 if (temp3)
38062 delete arg3;
38063 }
38064 return NULL;
38065 }
38066
38067
38068 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38069 PyObject *resultobj;
38070 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38071 wxString *arg2 = 0 ;
38072 int result;
38073 bool temp2 = false ;
38074 PyObject * obj0 = 0 ;
38075 PyObject * obj1 = 0 ;
38076 char *kwnames[] = {
38077 (char *) "self",(char *) "s", NULL
38078 };
38079
38080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38082 if (SWIG_arg_fail(1)) SWIG_fail;
38083 {
38084 arg2 = wxString_in_helper(obj1);
38085 if (arg2 == NULL) SWIG_fail;
38086 temp2 = true;
38087 }
38088 {
38089 PyThreadState* __tstate = wxPyBeginAllowThreads();
38090 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38091
38092 wxPyEndAllowThreads(__tstate);
38093 if (PyErr_Occurred()) SWIG_fail;
38094 }
38095 {
38096 resultobj = SWIG_From_int((int)(result));
38097 }
38098 {
38099 if (temp2)
38100 delete arg2;
38101 }
38102 return resultobj;
38103 fail:
38104 {
38105 if (temp2)
38106 delete arg2;
38107 }
38108 return NULL;
38109 }
38110
38111
38112 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38113 PyObject *resultobj;
38114 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38115 int arg2 ;
38116 PyObject * obj0 = 0 ;
38117 PyObject * obj1 = 0 ;
38118 char *kwnames[] = {
38119 (char *) "self",(char *) "n", NULL
38120 };
38121
38122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38124 if (SWIG_arg_fail(1)) SWIG_fail;
38125 {
38126 arg2 = (int)(SWIG_As_int(obj1));
38127 if (SWIG_arg_fail(2)) SWIG_fail;
38128 }
38129 {
38130 PyThreadState* __tstate = wxPyBeginAllowThreads();
38131 (arg1)->SetSelection(arg2);
38132
38133 wxPyEndAllowThreads(__tstate);
38134 if (PyErr_Occurred()) SWIG_fail;
38135 }
38136 Py_INCREF(Py_None); resultobj = Py_None;
38137 return resultobj;
38138 fail:
38139 return NULL;
38140 }
38141
38142
38143 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38144 PyObject *resultobj;
38145 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38146 int result;
38147 PyObject * obj0 = 0 ;
38148 char *kwnames[] = {
38149 (char *) "self", NULL
38150 };
38151
38152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38154 if (SWIG_arg_fail(1)) SWIG_fail;
38155 {
38156 PyThreadState* __tstate = wxPyBeginAllowThreads();
38157 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38158
38159 wxPyEndAllowThreads(__tstate);
38160 if (PyErr_Occurred()) SWIG_fail;
38161 }
38162 {
38163 resultobj = SWIG_From_int((int)(result));
38164 }
38165 return resultobj;
38166 fail:
38167 return NULL;
38168 }
38169
38170
38171 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38172 PyObject *resultobj;
38173 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38174 wxString *arg2 = 0 ;
38175 bool result;
38176 bool temp2 = false ;
38177 PyObject * obj0 = 0 ;
38178 PyObject * obj1 = 0 ;
38179 char *kwnames[] = {
38180 (char *) "self",(char *) "s", NULL
38181 };
38182
38183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38185 if (SWIG_arg_fail(1)) SWIG_fail;
38186 {
38187 arg2 = wxString_in_helper(obj1);
38188 if (arg2 == NULL) SWIG_fail;
38189 temp2 = true;
38190 }
38191 {
38192 PyThreadState* __tstate = wxPyBeginAllowThreads();
38193 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38194
38195 wxPyEndAllowThreads(__tstate);
38196 if (PyErr_Occurred()) SWIG_fail;
38197 }
38198 {
38199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38200 }
38201 {
38202 if (temp2)
38203 delete arg2;
38204 }
38205 return resultobj;
38206 fail:
38207 {
38208 if (temp2)
38209 delete arg2;
38210 }
38211 return NULL;
38212 }
38213
38214
38215 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj;
38217 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38218 wxString result;
38219 PyObject * obj0 = 0 ;
38220 char *kwnames[] = {
38221 (char *) "self", NULL
38222 };
38223
38224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38226 if (SWIG_arg_fail(1)) SWIG_fail;
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38230
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 {
38235 #if wxUSE_UNICODE
38236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38237 #else
38238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38239 #endif
38240 }
38241 return resultobj;
38242 fail:
38243 return NULL;
38244 }
38245
38246
38247 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38248 PyObject *resultobj;
38249 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38250 int arg2 ;
38251 PyObject * obj0 = 0 ;
38252 PyObject * obj1 = 0 ;
38253 char *kwnames[] = {
38254 (char *) "self",(char *) "n", NULL
38255 };
38256
38257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38259 if (SWIG_arg_fail(1)) SWIG_fail;
38260 {
38261 arg2 = (int)(SWIG_As_int(obj1));
38262 if (SWIG_arg_fail(2)) SWIG_fail;
38263 }
38264 {
38265 PyThreadState* __tstate = wxPyBeginAllowThreads();
38266 (arg1)->Select(arg2);
38267
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 Py_INCREF(Py_None); resultobj = Py_None;
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38279 PyObject *obj;
38280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38281 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38282 Py_INCREF(obj);
38283 return Py_BuildValue((char *)"");
38284 }
38285 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38286 PyObject *obj;
38287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38288 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38289 Py_INCREF(obj);
38290 return Py_BuildValue((char *)"");
38291 }
38292 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38293 PyObject *resultobj;
38294 wxSizerItem *result;
38295 char *kwnames[] = {
38296 NULL
38297 };
38298
38299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38300 {
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 result = (wxSizerItem *)new wxSizerItem();
38303
38304 wxPyEndAllowThreads(__tstate);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 }
38307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38308 return resultobj;
38309 fail:
38310 return NULL;
38311 }
38312
38313
38314 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38315 PyObject *resultobj;
38316 wxWindow *arg1 = (wxWindow *) 0 ;
38317 int arg2 ;
38318 int arg3 ;
38319 int arg4 ;
38320 PyObject *arg5 = (PyObject *) NULL ;
38321 wxSizerItem *result;
38322 PyObject * obj0 = 0 ;
38323 PyObject * obj1 = 0 ;
38324 PyObject * obj2 = 0 ;
38325 PyObject * obj3 = 0 ;
38326 PyObject * obj4 = 0 ;
38327 char *kwnames[] = {
38328 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38329 };
38330
38331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38333 if (SWIG_arg_fail(1)) SWIG_fail;
38334 {
38335 arg2 = (int)(SWIG_As_int(obj1));
38336 if (SWIG_arg_fail(2)) SWIG_fail;
38337 }
38338 {
38339 arg3 = (int)(SWIG_As_int(obj2));
38340 if (SWIG_arg_fail(3)) SWIG_fail;
38341 }
38342 {
38343 arg4 = (int)(SWIG_As_int(obj3));
38344 if (SWIG_arg_fail(4)) SWIG_fail;
38345 }
38346 if (obj4) {
38347 arg5 = obj4;
38348 }
38349 {
38350 PyThreadState* __tstate = wxPyBeginAllowThreads();
38351 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38352
38353 wxPyEndAllowThreads(__tstate);
38354 if (PyErr_Occurred()) SWIG_fail;
38355 }
38356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38357 return resultobj;
38358 fail:
38359 return NULL;
38360 }
38361
38362
38363 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38364 PyObject *resultobj;
38365 int arg1 ;
38366 int arg2 ;
38367 int arg3 ;
38368 int arg4 ;
38369 int arg5 ;
38370 PyObject *arg6 = (PyObject *) NULL ;
38371 wxSizerItem *result;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 PyObject * obj2 = 0 ;
38375 PyObject * obj3 = 0 ;
38376 PyObject * obj4 = 0 ;
38377 PyObject * obj5 = 0 ;
38378 char *kwnames[] = {
38379 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38380 };
38381
38382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38383 {
38384 arg1 = (int)(SWIG_As_int(obj0));
38385 if (SWIG_arg_fail(1)) SWIG_fail;
38386 }
38387 {
38388 arg2 = (int)(SWIG_As_int(obj1));
38389 if (SWIG_arg_fail(2)) SWIG_fail;
38390 }
38391 {
38392 arg3 = (int)(SWIG_As_int(obj2));
38393 if (SWIG_arg_fail(3)) SWIG_fail;
38394 }
38395 {
38396 arg4 = (int)(SWIG_As_int(obj3));
38397 if (SWIG_arg_fail(4)) SWIG_fail;
38398 }
38399 {
38400 arg5 = (int)(SWIG_As_int(obj4));
38401 if (SWIG_arg_fail(5)) SWIG_fail;
38402 }
38403 if (obj5) {
38404 arg6 = obj5;
38405 }
38406 {
38407 PyThreadState* __tstate = wxPyBeginAllowThreads();
38408 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38409
38410 wxPyEndAllowThreads(__tstate);
38411 if (PyErr_Occurred()) SWIG_fail;
38412 }
38413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38414 return resultobj;
38415 fail:
38416 return NULL;
38417 }
38418
38419
38420 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38421 PyObject *resultobj;
38422 wxSizer *arg1 = (wxSizer *) 0 ;
38423 int arg2 ;
38424 int arg3 ;
38425 int arg4 ;
38426 PyObject *arg5 = (PyObject *) NULL ;
38427 wxSizerItem *result;
38428 PyObject * obj0 = 0 ;
38429 PyObject * obj1 = 0 ;
38430 PyObject * obj2 = 0 ;
38431 PyObject * obj3 = 0 ;
38432 PyObject * obj4 = 0 ;
38433 char *kwnames[] = {
38434 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38435 };
38436
38437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38439 if (SWIG_arg_fail(1)) SWIG_fail;
38440 {
38441 arg2 = (int)(SWIG_As_int(obj1));
38442 if (SWIG_arg_fail(2)) SWIG_fail;
38443 }
38444 {
38445 arg3 = (int)(SWIG_As_int(obj2));
38446 if (SWIG_arg_fail(3)) SWIG_fail;
38447 }
38448 {
38449 arg4 = (int)(SWIG_As_int(obj3));
38450 if (SWIG_arg_fail(4)) SWIG_fail;
38451 }
38452 if (obj4) {
38453 arg5 = obj4;
38454 }
38455 {
38456 PyThreadState* __tstate = wxPyBeginAllowThreads();
38457 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38458
38459 wxPyEndAllowThreads(__tstate);
38460 if (PyErr_Occurred()) SWIG_fail;
38461 }
38462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38463 return resultobj;
38464 fail:
38465 return NULL;
38466 }
38467
38468
38469 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38470 PyObject *resultobj;
38471 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38472 PyObject * obj0 = 0 ;
38473 char *kwnames[] = {
38474 (char *) "self", NULL
38475 };
38476
38477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38479 if (SWIG_arg_fail(1)) SWIG_fail;
38480 {
38481 PyThreadState* __tstate = wxPyBeginAllowThreads();
38482 (arg1)->DeleteWindows();
38483
38484 wxPyEndAllowThreads(__tstate);
38485 if (PyErr_Occurred()) SWIG_fail;
38486 }
38487 Py_INCREF(Py_None); resultobj = Py_None;
38488 return resultobj;
38489 fail:
38490 return NULL;
38491 }
38492
38493
38494 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38495 PyObject *resultobj;
38496 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38497 PyObject * obj0 = 0 ;
38498 char *kwnames[] = {
38499 (char *) "self", NULL
38500 };
38501
38502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38504 if (SWIG_arg_fail(1)) SWIG_fail;
38505 {
38506 PyThreadState* __tstate = wxPyBeginAllowThreads();
38507 (arg1)->DetachSizer();
38508
38509 wxPyEndAllowThreads(__tstate);
38510 if (PyErr_Occurred()) SWIG_fail;
38511 }
38512 Py_INCREF(Py_None); resultobj = Py_None;
38513 return resultobj;
38514 fail:
38515 return NULL;
38516 }
38517
38518
38519 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38520 PyObject *resultobj;
38521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38522 wxSize result;
38523 PyObject * obj0 = 0 ;
38524 char *kwnames[] = {
38525 (char *) "self", NULL
38526 };
38527
38528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38530 if (SWIG_arg_fail(1)) SWIG_fail;
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 result = (arg1)->GetSize();
38534
38535 wxPyEndAllowThreads(__tstate);
38536 if (PyErr_Occurred()) SWIG_fail;
38537 }
38538 {
38539 wxSize * resultptr;
38540 resultptr = new wxSize((wxSize &)(result));
38541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38542 }
38543 return resultobj;
38544 fail:
38545 return NULL;
38546 }
38547
38548
38549 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38550 PyObject *resultobj;
38551 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38552 wxSize result;
38553 PyObject * obj0 = 0 ;
38554 char *kwnames[] = {
38555 (char *) "self", NULL
38556 };
38557
38558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38560 if (SWIG_arg_fail(1)) SWIG_fail;
38561 {
38562 PyThreadState* __tstate = wxPyBeginAllowThreads();
38563 result = (arg1)->CalcMin();
38564
38565 wxPyEndAllowThreads(__tstate);
38566 if (PyErr_Occurred()) SWIG_fail;
38567 }
38568 {
38569 wxSize * resultptr;
38570 resultptr = new wxSize((wxSize &)(result));
38571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38572 }
38573 return resultobj;
38574 fail:
38575 return NULL;
38576 }
38577
38578
38579 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38580 PyObject *resultobj;
38581 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38582 wxPoint arg2 ;
38583 wxSize arg3 ;
38584 PyObject * obj0 = 0 ;
38585 PyObject * obj1 = 0 ;
38586 PyObject * obj2 = 0 ;
38587 char *kwnames[] = {
38588 (char *) "self",(char *) "pos",(char *) "size", NULL
38589 };
38590
38591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38593 if (SWIG_arg_fail(1)) SWIG_fail;
38594 {
38595 wxPoint * argp;
38596 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38597 if (SWIG_arg_fail(2)) SWIG_fail;
38598 if (argp == NULL) {
38599 SWIG_null_ref("wxPoint");
38600 }
38601 if (SWIG_arg_fail(2)) SWIG_fail;
38602 arg2 = *argp;
38603 }
38604 {
38605 wxSize * argp;
38606 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38607 if (SWIG_arg_fail(3)) SWIG_fail;
38608 if (argp == NULL) {
38609 SWIG_null_ref("wxSize");
38610 }
38611 if (SWIG_arg_fail(3)) SWIG_fail;
38612 arg3 = *argp;
38613 }
38614 {
38615 PyThreadState* __tstate = wxPyBeginAllowThreads();
38616 (arg1)->SetDimension(arg2,arg3);
38617
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 Py_INCREF(Py_None); resultobj = Py_None;
38622 return resultobj;
38623 fail:
38624 return NULL;
38625 }
38626
38627
38628 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38629 PyObject *resultobj;
38630 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38631 wxSize result;
38632 PyObject * obj0 = 0 ;
38633 char *kwnames[] = {
38634 (char *) "self", NULL
38635 };
38636
38637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38639 if (SWIG_arg_fail(1)) SWIG_fail;
38640 {
38641 PyThreadState* __tstate = wxPyBeginAllowThreads();
38642 result = (arg1)->GetMinSize();
38643
38644 wxPyEndAllowThreads(__tstate);
38645 if (PyErr_Occurred()) SWIG_fail;
38646 }
38647 {
38648 wxSize * resultptr;
38649 resultptr = new wxSize((wxSize &)(result));
38650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38651 }
38652 return resultobj;
38653 fail:
38654 return NULL;
38655 }
38656
38657
38658 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38659 PyObject *resultobj;
38660 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38661 wxSize result;
38662 PyObject * obj0 = 0 ;
38663 char *kwnames[] = {
38664 (char *) "self", NULL
38665 };
38666
38667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38669 if (SWIG_arg_fail(1)) SWIG_fail;
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38673
38674 wxPyEndAllowThreads(__tstate);
38675 if (PyErr_Occurred()) SWIG_fail;
38676 }
38677 {
38678 wxSize * resultptr;
38679 resultptr = new wxSize((wxSize &)(result));
38680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38681 }
38682 return resultobj;
38683 fail:
38684 return NULL;
38685 }
38686
38687
38688 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38689 PyObject *resultobj;
38690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38691 int arg2 ;
38692 int arg3 ;
38693 PyObject * obj0 = 0 ;
38694 PyObject * obj1 = 0 ;
38695 PyObject * obj2 = 0 ;
38696 char *kwnames[] = {
38697 (char *) "self",(char *) "x",(char *) "y", NULL
38698 };
38699
38700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38702 if (SWIG_arg_fail(1)) SWIG_fail;
38703 {
38704 arg2 = (int)(SWIG_As_int(obj1));
38705 if (SWIG_arg_fail(2)) SWIG_fail;
38706 }
38707 {
38708 arg3 = (int)(SWIG_As_int(obj2));
38709 if (SWIG_arg_fail(3)) SWIG_fail;
38710 }
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 (arg1)->SetInitSize(arg2,arg3);
38714
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 Py_INCREF(Py_None); resultobj = Py_None;
38719 return resultobj;
38720 fail:
38721 return NULL;
38722 }
38723
38724
38725 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38726 PyObject *resultobj;
38727 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38728 int arg2 ;
38729 int arg3 ;
38730 PyObject * obj0 = 0 ;
38731 PyObject * obj1 = 0 ;
38732 PyObject * obj2 = 0 ;
38733 char *kwnames[] = {
38734 (char *) "self",(char *) "width",(char *) "height", NULL
38735 };
38736
38737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38739 if (SWIG_arg_fail(1)) SWIG_fail;
38740 {
38741 arg2 = (int)(SWIG_As_int(obj1));
38742 if (SWIG_arg_fail(2)) SWIG_fail;
38743 }
38744 {
38745 arg3 = (int)(SWIG_As_int(obj2));
38746 if (SWIG_arg_fail(3)) SWIG_fail;
38747 }
38748 {
38749 PyThreadState* __tstate = wxPyBeginAllowThreads();
38750 (arg1)->SetRatio(arg2,arg3);
38751
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 Py_INCREF(Py_None); resultobj = Py_None;
38756 return resultobj;
38757 fail:
38758 return NULL;
38759 }
38760
38761
38762 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38763 PyObject *resultobj;
38764 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38765 wxSize *arg2 = 0 ;
38766 wxSize temp2 ;
38767 PyObject * obj0 = 0 ;
38768 PyObject * obj1 = 0 ;
38769 char *kwnames[] = {
38770 (char *) "self",(char *) "size", NULL
38771 };
38772
38773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38775 if (SWIG_arg_fail(1)) SWIG_fail;
38776 {
38777 arg2 = &temp2;
38778 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38779 }
38780 {
38781 PyThreadState* __tstate = wxPyBeginAllowThreads();
38782 (arg1)->SetRatio((wxSize const &)*arg2);
38783
38784 wxPyEndAllowThreads(__tstate);
38785 if (PyErr_Occurred()) SWIG_fail;
38786 }
38787 Py_INCREF(Py_None); resultobj = Py_None;
38788 return resultobj;
38789 fail:
38790 return NULL;
38791 }
38792
38793
38794 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38795 PyObject *resultobj;
38796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38797 float arg2 ;
38798 PyObject * obj0 = 0 ;
38799 PyObject * obj1 = 0 ;
38800 char *kwnames[] = {
38801 (char *) "self",(char *) "ratio", NULL
38802 };
38803
38804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38806 if (SWIG_arg_fail(1)) SWIG_fail;
38807 {
38808 arg2 = (float)(SWIG_As_float(obj1));
38809 if (SWIG_arg_fail(2)) SWIG_fail;
38810 }
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 (arg1)->SetRatio(arg2);
38814
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 Py_INCREF(Py_None); resultobj = Py_None;
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38826 PyObject *resultobj;
38827 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38828 float result;
38829 PyObject * obj0 = 0 ;
38830 char *kwnames[] = {
38831 (char *) "self", NULL
38832 };
38833
38834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38836 if (SWIG_arg_fail(1)) SWIG_fail;
38837 {
38838 PyThreadState* __tstate = wxPyBeginAllowThreads();
38839 result = (float)(arg1)->GetRatio();
38840
38841 wxPyEndAllowThreads(__tstate);
38842 if (PyErr_Occurred()) SWIG_fail;
38843 }
38844 {
38845 resultobj = SWIG_From_float((float)(result));
38846 }
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38854 PyObject *resultobj;
38855 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38856 wxRect result;
38857 PyObject * obj0 = 0 ;
38858 char *kwnames[] = {
38859 (char *) "self", NULL
38860 };
38861
38862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38864 if (SWIG_arg_fail(1)) SWIG_fail;
38865 {
38866 PyThreadState* __tstate = wxPyBeginAllowThreads();
38867 result = (arg1)->GetRect();
38868
38869 wxPyEndAllowThreads(__tstate);
38870 if (PyErr_Occurred()) SWIG_fail;
38871 }
38872 {
38873 wxRect * resultptr;
38874 resultptr = new wxRect((wxRect &)(result));
38875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38876 }
38877 return resultobj;
38878 fail:
38879 return NULL;
38880 }
38881
38882
38883 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38884 PyObject *resultobj;
38885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38886 bool result;
38887 PyObject * obj0 = 0 ;
38888 char *kwnames[] = {
38889 (char *) "self", NULL
38890 };
38891
38892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38894 if (SWIG_arg_fail(1)) SWIG_fail;
38895 {
38896 PyThreadState* __tstate = wxPyBeginAllowThreads();
38897 result = (bool)(arg1)->IsWindow();
38898
38899 wxPyEndAllowThreads(__tstate);
38900 if (PyErr_Occurred()) SWIG_fail;
38901 }
38902 {
38903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38904 }
38905 return resultobj;
38906 fail:
38907 return NULL;
38908 }
38909
38910
38911 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38912 PyObject *resultobj;
38913 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38914 bool result;
38915 PyObject * obj0 = 0 ;
38916 char *kwnames[] = {
38917 (char *) "self", NULL
38918 };
38919
38920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38922 if (SWIG_arg_fail(1)) SWIG_fail;
38923 {
38924 PyThreadState* __tstate = wxPyBeginAllowThreads();
38925 result = (bool)(arg1)->IsSizer();
38926
38927 wxPyEndAllowThreads(__tstate);
38928 if (PyErr_Occurred()) SWIG_fail;
38929 }
38930 {
38931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38932 }
38933 return resultobj;
38934 fail:
38935 return NULL;
38936 }
38937
38938
38939 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38940 PyObject *resultobj;
38941 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38942 bool result;
38943 PyObject * obj0 = 0 ;
38944 char *kwnames[] = {
38945 (char *) "self", NULL
38946 };
38947
38948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38950 if (SWIG_arg_fail(1)) SWIG_fail;
38951 {
38952 PyThreadState* __tstate = wxPyBeginAllowThreads();
38953 result = (bool)(arg1)->IsSpacer();
38954
38955 wxPyEndAllowThreads(__tstate);
38956 if (PyErr_Occurred()) SWIG_fail;
38957 }
38958 {
38959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38960 }
38961 return resultobj;
38962 fail:
38963 return NULL;
38964 }
38965
38966
38967 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38968 PyObject *resultobj;
38969 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38970 int arg2 ;
38971 PyObject * obj0 = 0 ;
38972 PyObject * obj1 = 0 ;
38973 char *kwnames[] = {
38974 (char *) "self",(char *) "proportion", NULL
38975 };
38976
38977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38979 if (SWIG_arg_fail(1)) SWIG_fail;
38980 {
38981 arg2 = (int)(SWIG_As_int(obj1));
38982 if (SWIG_arg_fail(2)) SWIG_fail;
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 (arg1)->SetProportion(arg2);
38987
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 Py_INCREF(Py_None); resultobj = Py_None;
38992 return resultobj;
38993 fail:
38994 return NULL;
38995 }
38996
38997
38998 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38999 PyObject *resultobj;
39000 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39001 int result;
39002 PyObject * obj0 = 0 ;
39003 char *kwnames[] = {
39004 (char *) "self", NULL
39005 };
39006
39007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39009 if (SWIG_arg_fail(1)) SWIG_fail;
39010 {
39011 PyThreadState* __tstate = wxPyBeginAllowThreads();
39012 result = (int)(arg1)->GetProportion();
39013
39014 wxPyEndAllowThreads(__tstate);
39015 if (PyErr_Occurred()) SWIG_fail;
39016 }
39017 {
39018 resultobj = SWIG_From_int((int)(result));
39019 }
39020 return resultobj;
39021 fail:
39022 return NULL;
39023 }
39024
39025
39026 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39027 PyObject *resultobj;
39028 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39029 int arg2 ;
39030 PyObject * obj0 = 0 ;
39031 PyObject * obj1 = 0 ;
39032 char *kwnames[] = {
39033 (char *) "self",(char *) "flag", NULL
39034 };
39035
39036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39038 if (SWIG_arg_fail(1)) SWIG_fail;
39039 {
39040 arg2 = (int)(SWIG_As_int(obj1));
39041 if (SWIG_arg_fail(2)) SWIG_fail;
39042 }
39043 {
39044 PyThreadState* __tstate = wxPyBeginAllowThreads();
39045 (arg1)->SetFlag(arg2);
39046
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 Py_INCREF(Py_None); resultobj = Py_None;
39051 return resultobj;
39052 fail:
39053 return NULL;
39054 }
39055
39056
39057 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39058 PyObject *resultobj;
39059 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39060 int result;
39061 PyObject * obj0 = 0 ;
39062 char *kwnames[] = {
39063 (char *) "self", NULL
39064 };
39065
39066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39068 if (SWIG_arg_fail(1)) SWIG_fail;
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 result = (int)(arg1)->GetFlag();
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 {
39077 resultobj = SWIG_From_int((int)(result));
39078 }
39079 return resultobj;
39080 fail:
39081 return NULL;
39082 }
39083
39084
39085 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj;
39087 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39088 int arg2 ;
39089 PyObject * obj0 = 0 ;
39090 PyObject * obj1 = 0 ;
39091 char *kwnames[] = {
39092 (char *) "self",(char *) "border", NULL
39093 };
39094
39095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39097 if (SWIG_arg_fail(1)) SWIG_fail;
39098 {
39099 arg2 = (int)(SWIG_As_int(obj1));
39100 if (SWIG_arg_fail(2)) SWIG_fail;
39101 }
39102 {
39103 PyThreadState* __tstate = wxPyBeginAllowThreads();
39104 (arg1)->SetBorder(arg2);
39105
39106 wxPyEndAllowThreads(__tstate);
39107 if (PyErr_Occurred()) SWIG_fail;
39108 }
39109 Py_INCREF(Py_None); resultobj = Py_None;
39110 return resultobj;
39111 fail:
39112 return NULL;
39113 }
39114
39115
39116 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39117 PyObject *resultobj;
39118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39119 int result;
39120 PyObject * obj0 = 0 ;
39121 char *kwnames[] = {
39122 (char *) "self", NULL
39123 };
39124
39125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39127 if (SWIG_arg_fail(1)) SWIG_fail;
39128 {
39129 PyThreadState* __tstate = wxPyBeginAllowThreads();
39130 result = (int)(arg1)->GetBorder();
39131
39132 wxPyEndAllowThreads(__tstate);
39133 if (PyErr_Occurred()) SWIG_fail;
39134 }
39135 {
39136 resultobj = SWIG_From_int((int)(result));
39137 }
39138 return resultobj;
39139 fail:
39140 return NULL;
39141 }
39142
39143
39144 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39145 PyObject *resultobj;
39146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39147 wxWindow *result;
39148 PyObject * obj0 = 0 ;
39149 char *kwnames[] = {
39150 (char *) "self", NULL
39151 };
39152
39153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39155 if (SWIG_arg_fail(1)) SWIG_fail;
39156 {
39157 PyThreadState* __tstate = wxPyBeginAllowThreads();
39158 result = (wxWindow *)(arg1)->GetWindow();
39159
39160 wxPyEndAllowThreads(__tstate);
39161 if (PyErr_Occurred()) SWIG_fail;
39162 }
39163 {
39164 resultobj = wxPyMake_wxObject(result, 0);
39165 }
39166 return resultobj;
39167 fail:
39168 return NULL;
39169 }
39170
39171
39172 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39173 PyObject *resultobj;
39174 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39175 wxWindow *arg2 = (wxWindow *) 0 ;
39176 PyObject * obj0 = 0 ;
39177 PyObject * obj1 = 0 ;
39178 char *kwnames[] = {
39179 (char *) "self",(char *) "window", NULL
39180 };
39181
39182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39184 if (SWIG_arg_fail(1)) SWIG_fail;
39185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39186 if (SWIG_arg_fail(2)) SWIG_fail;
39187 {
39188 PyThreadState* __tstate = wxPyBeginAllowThreads();
39189 (arg1)->SetWindow(arg2);
39190
39191 wxPyEndAllowThreads(__tstate);
39192 if (PyErr_Occurred()) SWIG_fail;
39193 }
39194 Py_INCREF(Py_None); resultobj = Py_None;
39195 return resultobj;
39196 fail:
39197 return NULL;
39198 }
39199
39200
39201 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39202 PyObject *resultobj;
39203 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39204 wxSizer *result;
39205 PyObject * obj0 = 0 ;
39206 char *kwnames[] = {
39207 (char *) "self", NULL
39208 };
39209
39210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39212 if (SWIG_arg_fail(1)) SWIG_fail;
39213 {
39214 PyThreadState* __tstate = wxPyBeginAllowThreads();
39215 result = (wxSizer *)(arg1)->GetSizer();
39216
39217 wxPyEndAllowThreads(__tstate);
39218 if (PyErr_Occurred()) SWIG_fail;
39219 }
39220 {
39221 resultobj = wxPyMake_wxSizer(result, 0);
39222 }
39223 return resultobj;
39224 fail:
39225 return NULL;
39226 }
39227
39228
39229 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39230 PyObject *resultobj;
39231 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39232 wxSizer *arg2 = (wxSizer *) 0 ;
39233 PyObject * obj0 = 0 ;
39234 PyObject * obj1 = 0 ;
39235 char *kwnames[] = {
39236 (char *) "self",(char *) "sizer", NULL
39237 };
39238
39239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39241 if (SWIG_arg_fail(1)) SWIG_fail;
39242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39243 if (SWIG_arg_fail(2)) SWIG_fail;
39244 {
39245 PyThreadState* __tstate = wxPyBeginAllowThreads();
39246 (arg1)->SetSizer(arg2);
39247
39248 wxPyEndAllowThreads(__tstate);
39249 if (PyErr_Occurred()) SWIG_fail;
39250 }
39251 Py_INCREF(Py_None); resultobj = Py_None;
39252 return resultobj;
39253 fail:
39254 return NULL;
39255 }
39256
39257
39258 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39259 PyObject *resultobj;
39260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39261 wxSize *result;
39262 PyObject * obj0 = 0 ;
39263 char *kwnames[] = {
39264 (char *) "self", NULL
39265 };
39266
39267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39269 if (SWIG_arg_fail(1)) SWIG_fail;
39270 {
39271 PyThreadState* __tstate = wxPyBeginAllowThreads();
39272 {
39273 wxSize const &_result_ref = (arg1)->GetSpacer();
39274 result = (wxSize *) &_result_ref;
39275 }
39276
39277 wxPyEndAllowThreads(__tstate);
39278 if (PyErr_Occurred()) SWIG_fail;
39279 }
39280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39281 return resultobj;
39282 fail:
39283 return NULL;
39284 }
39285
39286
39287 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39288 PyObject *resultobj;
39289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39290 wxSize *arg2 = 0 ;
39291 wxSize temp2 ;
39292 PyObject * obj0 = 0 ;
39293 PyObject * obj1 = 0 ;
39294 char *kwnames[] = {
39295 (char *) "self",(char *) "size", NULL
39296 };
39297
39298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39300 if (SWIG_arg_fail(1)) SWIG_fail;
39301 {
39302 arg2 = &temp2;
39303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39304 }
39305 {
39306 PyThreadState* __tstate = wxPyBeginAllowThreads();
39307 (arg1)->SetSpacer((wxSize const &)*arg2);
39308
39309 wxPyEndAllowThreads(__tstate);
39310 if (PyErr_Occurred()) SWIG_fail;
39311 }
39312 Py_INCREF(Py_None); resultobj = Py_None;
39313 return resultobj;
39314 fail:
39315 return NULL;
39316 }
39317
39318
39319 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39320 PyObject *resultobj;
39321 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39322 bool arg2 ;
39323 PyObject * obj0 = 0 ;
39324 PyObject * obj1 = 0 ;
39325 char *kwnames[] = {
39326 (char *) "self",(char *) "show", NULL
39327 };
39328
39329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39331 if (SWIG_arg_fail(1)) SWIG_fail;
39332 {
39333 arg2 = (bool)(SWIG_As_bool(obj1));
39334 if (SWIG_arg_fail(2)) SWIG_fail;
39335 }
39336 {
39337 PyThreadState* __tstate = wxPyBeginAllowThreads();
39338 (arg1)->Show(arg2);
39339
39340 wxPyEndAllowThreads(__tstate);
39341 if (PyErr_Occurred()) SWIG_fail;
39342 }
39343 Py_INCREF(Py_None); resultobj = Py_None;
39344 return resultobj;
39345 fail:
39346 return NULL;
39347 }
39348
39349
39350 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39351 PyObject *resultobj;
39352 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39353 bool result;
39354 PyObject * obj0 = 0 ;
39355 char *kwnames[] = {
39356 (char *) "self", NULL
39357 };
39358
39359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39361 if (SWIG_arg_fail(1)) SWIG_fail;
39362 {
39363 PyThreadState* __tstate = wxPyBeginAllowThreads();
39364 result = (bool)(arg1)->IsShown();
39365
39366 wxPyEndAllowThreads(__tstate);
39367 if (PyErr_Occurred()) SWIG_fail;
39368 }
39369 {
39370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39371 }
39372 return resultobj;
39373 fail:
39374 return NULL;
39375 }
39376
39377
39378 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39379 PyObject *resultobj;
39380 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39381 wxPoint result;
39382 PyObject * obj0 = 0 ;
39383 char *kwnames[] = {
39384 (char *) "self", NULL
39385 };
39386
39387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39389 if (SWIG_arg_fail(1)) SWIG_fail;
39390 {
39391 PyThreadState* __tstate = wxPyBeginAllowThreads();
39392 result = (arg1)->GetPosition();
39393
39394 wxPyEndAllowThreads(__tstate);
39395 if (PyErr_Occurred()) SWIG_fail;
39396 }
39397 {
39398 wxPoint * resultptr;
39399 resultptr = new wxPoint((wxPoint &)(result));
39400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39401 }
39402 return resultobj;
39403 fail:
39404 return NULL;
39405 }
39406
39407
39408 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39409 PyObject *resultobj;
39410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39411 PyObject *result;
39412 PyObject * obj0 = 0 ;
39413 char *kwnames[] = {
39414 (char *) "self", NULL
39415 };
39416
39417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39419 if (SWIG_arg_fail(1)) SWIG_fail;
39420 {
39421 PyThreadState* __tstate = wxPyBeginAllowThreads();
39422 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39423
39424 wxPyEndAllowThreads(__tstate);
39425 if (PyErr_Occurred()) SWIG_fail;
39426 }
39427 resultobj = result;
39428 return resultobj;
39429 fail:
39430 return NULL;
39431 }
39432
39433
39434 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39435 PyObject *obj;
39436 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39437 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39438 Py_INCREF(obj);
39439 return Py_BuildValue((char *)"");
39440 }
39441 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39442 PyObject *resultobj;
39443 wxSizer *arg1 = (wxSizer *) 0 ;
39444 PyObject *arg2 = (PyObject *) 0 ;
39445 PyObject * obj0 = 0 ;
39446 PyObject * obj1 = 0 ;
39447 char *kwnames[] = {
39448 (char *) "self",(char *) "_self", NULL
39449 };
39450
39451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39453 if (SWIG_arg_fail(1)) SWIG_fail;
39454 arg2 = obj1;
39455 {
39456 PyThreadState* __tstate = wxPyBeginAllowThreads();
39457 wxSizer__setOORInfo(arg1,arg2);
39458
39459 wxPyEndAllowThreads(__tstate);
39460 if (PyErr_Occurred()) SWIG_fail;
39461 }
39462 Py_INCREF(Py_None); resultobj = Py_None;
39463 return resultobj;
39464 fail:
39465 return NULL;
39466 }
39467
39468
39469 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39470 PyObject *resultobj;
39471 wxSizer *arg1 = (wxSizer *) 0 ;
39472 PyObject *arg2 = (PyObject *) 0 ;
39473 int arg3 = (int) 0 ;
39474 int arg4 = (int) 0 ;
39475 int arg5 = (int) 0 ;
39476 PyObject *arg6 = (PyObject *) NULL ;
39477 wxSizerItem *result;
39478 PyObject * obj0 = 0 ;
39479 PyObject * obj1 = 0 ;
39480 PyObject * obj2 = 0 ;
39481 PyObject * obj3 = 0 ;
39482 PyObject * obj4 = 0 ;
39483 PyObject * obj5 = 0 ;
39484 char *kwnames[] = {
39485 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39486 };
39487
39488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39490 if (SWIG_arg_fail(1)) SWIG_fail;
39491 arg2 = obj1;
39492 if (obj2) {
39493 {
39494 arg3 = (int)(SWIG_As_int(obj2));
39495 if (SWIG_arg_fail(3)) SWIG_fail;
39496 }
39497 }
39498 if (obj3) {
39499 {
39500 arg4 = (int)(SWIG_As_int(obj3));
39501 if (SWIG_arg_fail(4)) SWIG_fail;
39502 }
39503 }
39504 if (obj4) {
39505 {
39506 arg5 = (int)(SWIG_As_int(obj4));
39507 if (SWIG_arg_fail(5)) SWIG_fail;
39508 }
39509 }
39510 if (obj5) {
39511 arg6 = obj5;
39512 }
39513 {
39514 PyThreadState* __tstate = wxPyBeginAllowThreads();
39515 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39516
39517 wxPyEndAllowThreads(__tstate);
39518 if (PyErr_Occurred()) SWIG_fail;
39519 }
39520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39521 return resultobj;
39522 fail:
39523 return NULL;
39524 }
39525
39526
39527 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39528 PyObject *resultobj;
39529 wxSizer *arg1 = (wxSizer *) 0 ;
39530 int arg2 ;
39531 PyObject *arg3 = (PyObject *) 0 ;
39532 int arg4 = (int) 0 ;
39533 int arg5 = (int) 0 ;
39534 int arg6 = (int) 0 ;
39535 PyObject *arg7 = (PyObject *) NULL ;
39536 wxSizerItem *result;
39537 PyObject * obj0 = 0 ;
39538 PyObject * obj1 = 0 ;
39539 PyObject * obj2 = 0 ;
39540 PyObject * obj3 = 0 ;
39541 PyObject * obj4 = 0 ;
39542 PyObject * obj5 = 0 ;
39543 PyObject * obj6 = 0 ;
39544 char *kwnames[] = {
39545 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39546 };
39547
39548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39550 if (SWIG_arg_fail(1)) SWIG_fail;
39551 {
39552 arg2 = (int)(SWIG_As_int(obj1));
39553 if (SWIG_arg_fail(2)) SWIG_fail;
39554 }
39555 arg3 = obj2;
39556 if (obj3) {
39557 {
39558 arg4 = (int)(SWIG_As_int(obj3));
39559 if (SWIG_arg_fail(4)) SWIG_fail;
39560 }
39561 }
39562 if (obj4) {
39563 {
39564 arg5 = (int)(SWIG_As_int(obj4));
39565 if (SWIG_arg_fail(5)) SWIG_fail;
39566 }
39567 }
39568 if (obj5) {
39569 {
39570 arg6 = (int)(SWIG_As_int(obj5));
39571 if (SWIG_arg_fail(6)) SWIG_fail;
39572 }
39573 }
39574 if (obj6) {
39575 arg7 = obj6;
39576 }
39577 {
39578 PyThreadState* __tstate = wxPyBeginAllowThreads();
39579 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39580
39581 wxPyEndAllowThreads(__tstate);
39582 if (PyErr_Occurred()) SWIG_fail;
39583 }
39584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39585 return resultobj;
39586 fail:
39587 return NULL;
39588 }
39589
39590
39591 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39592 PyObject *resultobj;
39593 wxSizer *arg1 = (wxSizer *) 0 ;
39594 PyObject *arg2 = (PyObject *) 0 ;
39595 int arg3 = (int) 0 ;
39596 int arg4 = (int) 0 ;
39597 int arg5 = (int) 0 ;
39598 PyObject *arg6 = (PyObject *) NULL ;
39599 wxSizerItem *result;
39600 PyObject * obj0 = 0 ;
39601 PyObject * obj1 = 0 ;
39602 PyObject * obj2 = 0 ;
39603 PyObject * obj3 = 0 ;
39604 PyObject * obj4 = 0 ;
39605 PyObject * obj5 = 0 ;
39606 char *kwnames[] = {
39607 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39608 };
39609
39610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39612 if (SWIG_arg_fail(1)) SWIG_fail;
39613 arg2 = obj1;
39614 if (obj2) {
39615 {
39616 arg3 = (int)(SWIG_As_int(obj2));
39617 if (SWIG_arg_fail(3)) SWIG_fail;
39618 }
39619 }
39620 if (obj3) {
39621 {
39622 arg4 = (int)(SWIG_As_int(obj3));
39623 if (SWIG_arg_fail(4)) SWIG_fail;
39624 }
39625 }
39626 if (obj4) {
39627 {
39628 arg5 = (int)(SWIG_As_int(obj4));
39629 if (SWIG_arg_fail(5)) SWIG_fail;
39630 }
39631 }
39632 if (obj5) {
39633 arg6 = obj5;
39634 }
39635 {
39636 PyThreadState* __tstate = wxPyBeginAllowThreads();
39637 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39638
39639 wxPyEndAllowThreads(__tstate);
39640 if (PyErr_Occurred()) SWIG_fail;
39641 }
39642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39643 return resultobj;
39644 fail:
39645 return NULL;
39646 }
39647
39648
39649 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39650 PyObject *resultobj;
39651 wxSizer *arg1 = (wxSizer *) 0 ;
39652 PyObject *arg2 = (PyObject *) 0 ;
39653 bool result;
39654 PyObject * obj0 = 0 ;
39655 PyObject * obj1 = 0 ;
39656 char *kwnames[] = {
39657 (char *) "self",(char *) "item", NULL
39658 };
39659
39660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39662 if (SWIG_arg_fail(1)) SWIG_fail;
39663 arg2 = obj1;
39664 {
39665 PyThreadState* __tstate = wxPyBeginAllowThreads();
39666 result = (bool)wxSizer_Remove(arg1,arg2);
39667
39668 wxPyEndAllowThreads(__tstate);
39669 if (PyErr_Occurred()) SWIG_fail;
39670 }
39671 {
39672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39673 }
39674 return resultobj;
39675 fail:
39676 return NULL;
39677 }
39678
39679
39680 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39681 PyObject *resultobj;
39682 wxSizer *arg1 = (wxSizer *) 0 ;
39683 PyObject *arg2 = (PyObject *) 0 ;
39684 bool result;
39685 PyObject * obj0 = 0 ;
39686 PyObject * obj1 = 0 ;
39687 char *kwnames[] = {
39688 (char *) "self",(char *) "item", NULL
39689 };
39690
39691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39693 if (SWIG_arg_fail(1)) SWIG_fail;
39694 arg2 = obj1;
39695 {
39696 PyThreadState* __tstate = wxPyBeginAllowThreads();
39697 result = (bool)wxSizer_Detach(arg1,arg2);
39698
39699 wxPyEndAllowThreads(__tstate);
39700 if (PyErr_Occurred()) SWIG_fail;
39701 }
39702 {
39703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39704 }
39705 return resultobj;
39706 fail:
39707 return NULL;
39708 }
39709
39710
39711 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39712 PyObject *resultobj;
39713 wxSizer *arg1 = (wxSizer *) 0 ;
39714 PyObject *arg2 = (PyObject *) 0 ;
39715 wxSizerItem *result;
39716 PyObject * obj0 = 0 ;
39717 PyObject * obj1 = 0 ;
39718 char *kwnames[] = {
39719 (char *) "self",(char *) "item", NULL
39720 };
39721
39722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39724 if (SWIG_arg_fail(1)) SWIG_fail;
39725 arg2 = obj1;
39726 {
39727 PyThreadState* __tstate = wxPyBeginAllowThreads();
39728 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39729
39730 wxPyEndAllowThreads(__tstate);
39731 if (PyErr_Occurred()) SWIG_fail;
39732 }
39733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39734 return resultobj;
39735 fail:
39736 return NULL;
39737 }
39738
39739
39740 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39741 PyObject *resultobj;
39742 wxSizer *arg1 = (wxSizer *) 0 ;
39743 PyObject *arg2 = (PyObject *) 0 ;
39744 wxSize *arg3 = 0 ;
39745 wxSize temp3 ;
39746 PyObject * obj0 = 0 ;
39747 PyObject * obj1 = 0 ;
39748 PyObject * obj2 = 0 ;
39749 char *kwnames[] = {
39750 (char *) "self",(char *) "item",(char *) "size", NULL
39751 };
39752
39753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39755 if (SWIG_arg_fail(1)) SWIG_fail;
39756 arg2 = obj1;
39757 {
39758 arg3 = &temp3;
39759 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39760 }
39761 {
39762 PyThreadState* __tstate = wxPyBeginAllowThreads();
39763 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39764
39765 wxPyEndAllowThreads(__tstate);
39766 if (PyErr_Occurred()) SWIG_fail;
39767 }
39768 Py_INCREF(Py_None); resultobj = Py_None;
39769 return resultobj;
39770 fail:
39771 return NULL;
39772 }
39773
39774
39775 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39776 PyObject *resultobj;
39777 wxSizer *arg1 = (wxSizer *) 0 ;
39778 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39779 wxSizerItem *result;
39780 PyObject * obj0 = 0 ;
39781 PyObject * obj1 = 0 ;
39782 char *kwnames[] = {
39783 (char *) "self",(char *) "item", NULL
39784 };
39785
39786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39788 if (SWIG_arg_fail(1)) SWIG_fail;
39789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39790 if (SWIG_arg_fail(2)) SWIG_fail;
39791 {
39792 PyThreadState* __tstate = wxPyBeginAllowThreads();
39793 result = (wxSizerItem *)(arg1)->Add(arg2);
39794
39795 wxPyEndAllowThreads(__tstate);
39796 if (PyErr_Occurred()) SWIG_fail;
39797 }
39798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39799 return resultobj;
39800 fail:
39801 return NULL;
39802 }
39803
39804
39805 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39806 PyObject *resultobj;
39807 wxSizer *arg1 = (wxSizer *) 0 ;
39808 size_t arg2 ;
39809 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39810 wxSizerItem *result;
39811 PyObject * obj0 = 0 ;
39812 PyObject * obj1 = 0 ;
39813 PyObject * obj2 = 0 ;
39814 char *kwnames[] = {
39815 (char *) "self",(char *) "index",(char *) "item", NULL
39816 };
39817
39818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39820 if (SWIG_arg_fail(1)) SWIG_fail;
39821 {
39822 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39823 if (SWIG_arg_fail(2)) SWIG_fail;
39824 }
39825 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39826 if (SWIG_arg_fail(3)) SWIG_fail;
39827 {
39828 PyThreadState* __tstate = wxPyBeginAllowThreads();
39829 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39830
39831 wxPyEndAllowThreads(__tstate);
39832 if (PyErr_Occurred()) SWIG_fail;
39833 }
39834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39835 return resultobj;
39836 fail:
39837 return NULL;
39838 }
39839
39840
39841 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39842 PyObject *resultobj;
39843 wxSizer *arg1 = (wxSizer *) 0 ;
39844 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39845 wxSizerItem *result;
39846 PyObject * obj0 = 0 ;
39847 PyObject * obj1 = 0 ;
39848 char *kwnames[] = {
39849 (char *) "self",(char *) "item", NULL
39850 };
39851
39852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39854 if (SWIG_arg_fail(1)) SWIG_fail;
39855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39856 if (SWIG_arg_fail(2)) SWIG_fail;
39857 {
39858 PyThreadState* __tstate = wxPyBeginAllowThreads();
39859 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39860
39861 wxPyEndAllowThreads(__tstate);
39862 if (PyErr_Occurred()) SWIG_fail;
39863 }
39864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39865 return resultobj;
39866 fail:
39867 return NULL;
39868 }
39869
39870
39871 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39872 PyObject *resultobj;
39873 wxSizer *arg1 = (wxSizer *) 0 ;
39874 int arg2 ;
39875 int arg3 ;
39876 int arg4 ;
39877 int arg5 ;
39878 PyObject * obj0 = 0 ;
39879 PyObject * obj1 = 0 ;
39880 PyObject * obj2 = 0 ;
39881 PyObject * obj3 = 0 ;
39882 PyObject * obj4 = 0 ;
39883 char *kwnames[] = {
39884 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39885 };
39886
39887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39889 if (SWIG_arg_fail(1)) SWIG_fail;
39890 {
39891 arg2 = (int)(SWIG_As_int(obj1));
39892 if (SWIG_arg_fail(2)) SWIG_fail;
39893 }
39894 {
39895 arg3 = (int)(SWIG_As_int(obj2));
39896 if (SWIG_arg_fail(3)) SWIG_fail;
39897 }
39898 {
39899 arg4 = (int)(SWIG_As_int(obj3));
39900 if (SWIG_arg_fail(4)) SWIG_fail;
39901 }
39902 {
39903 arg5 = (int)(SWIG_As_int(obj4));
39904 if (SWIG_arg_fail(5)) SWIG_fail;
39905 }
39906 {
39907 PyThreadState* __tstate = wxPyBeginAllowThreads();
39908 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39909
39910 wxPyEndAllowThreads(__tstate);
39911 if (PyErr_Occurred()) SWIG_fail;
39912 }
39913 Py_INCREF(Py_None); resultobj = Py_None;
39914 return resultobj;
39915 fail:
39916 return NULL;
39917 }
39918
39919
39920 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39921 PyObject *resultobj;
39922 wxSizer *arg1 = (wxSizer *) 0 ;
39923 wxSize *arg2 = 0 ;
39924 wxSize temp2 ;
39925 PyObject * obj0 = 0 ;
39926 PyObject * obj1 = 0 ;
39927 char *kwnames[] = {
39928 (char *) "self",(char *) "size", NULL
39929 };
39930
39931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39933 if (SWIG_arg_fail(1)) SWIG_fail;
39934 {
39935 arg2 = &temp2;
39936 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39937 }
39938 {
39939 PyThreadState* __tstate = wxPyBeginAllowThreads();
39940 (arg1)->SetMinSize((wxSize const &)*arg2);
39941
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 Py_INCREF(Py_None); resultobj = Py_None;
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj;
39954 wxSizer *arg1 = (wxSizer *) 0 ;
39955 wxSize result;
39956 PyObject * obj0 = 0 ;
39957 char *kwnames[] = {
39958 (char *) "self", NULL
39959 };
39960
39961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39963 if (SWIG_arg_fail(1)) SWIG_fail;
39964 {
39965 PyThreadState* __tstate = wxPyBeginAllowThreads();
39966 result = (arg1)->GetSize();
39967
39968 wxPyEndAllowThreads(__tstate);
39969 if (PyErr_Occurred()) SWIG_fail;
39970 }
39971 {
39972 wxSize * resultptr;
39973 resultptr = new wxSize((wxSize &)(result));
39974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39975 }
39976 return resultobj;
39977 fail:
39978 return NULL;
39979 }
39980
39981
39982 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39983 PyObject *resultobj;
39984 wxSizer *arg1 = (wxSizer *) 0 ;
39985 wxPoint result;
39986 PyObject * obj0 = 0 ;
39987 char *kwnames[] = {
39988 (char *) "self", NULL
39989 };
39990
39991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39993 if (SWIG_arg_fail(1)) SWIG_fail;
39994 {
39995 PyThreadState* __tstate = wxPyBeginAllowThreads();
39996 result = (arg1)->GetPosition();
39997
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 {
40002 wxPoint * resultptr;
40003 resultptr = new wxPoint((wxPoint &)(result));
40004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40005 }
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj;
40014 wxSizer *arg1 = (wxSizer *) 0 ;
40015 wxSize result;
40016 PyObject * obj0 = 0 ;
40017 char *kwnames[] = {
40018 (char *) "self", NULL
40019 };
40020
40021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40023 if (SWIG_arg_fail(1)) SWIG_fail;
40024 {
40025 PyThreadState* __tstate = wxPyBeginAllowThreads();
40026 result = (arg1)->GetMinSize();
40027
40028 wxPyEndAllowThreads(__tstate);
40029 if (PyErr_Occurred()) SWIG_fail;
40030 }
40031 {
40032 wxSize * resultptr;
40033 resultptr = new wxSize((wxSize &)(result));
40034 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40035 }
40036 return resultobj;
40037 fail:
40038 return NULL;
40039 }
40040
40041
40042 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj;
40044 wxSizer *arg1 = (wxSizer *) 0 ;
40045 PyObject * obj0 = 0 ;
40046 char *kwnames[] = {
40047 (char *) "self", NULL
40048 };
40049
40050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40052 if (SWIG_arg_fail(1)) SWIG_fail;
40053 {
40054 PyThreadState* __tstate = wxPyBeginAllowThreads();
40055 (arg1)->RecalcSizes();
40056
40057 wxPyEndAllowThreads(__tstate);
40058 if (PyErr_Occurred()) SWIG_fail;
40059 }
40060 Py_INCREF(Py_None); resultobj = Py_None;
40061 return resultobj;
40062 fail:
40063 return NULL;
40064 }
40065
40066
40067 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40068 PyObject *resultobj;
40069 wxSizer *arg1 = (wxSizer *) 0 ;
40070 wxSize result;
40071 PyObject * obj0 = 0 ;
40072 char *kwnames[] = {
40073 (char *) "self", NULL
40074 };
40075
40076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40078 if (SWIG_arg_fail(1)) SWIG_fail;
40079 {
40080 PyThreadState* __tstate = wxPyBeginAllowThreads();
40081 result = (arg1)->CalcMin();
40082
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 {
40087 wxSize * resultptr;
40088 resultptr = new wxSize((wxSize &)(result));
40089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40090 }
40091 return resultobj;
40092 fail:
40093 return NULL;
40094 }
40095
40096
40097 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40098 PyObject *resultobj;
40099 wxSizer *arg1 = (wxSizer *) 0 ;
40100 PyObject * obj0 = 0 ;
40101 char *kwnames[] = {
40102 (char *) "self", NULL
40103 };
40104
40105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40107 if (SWIG_arg_fail(1)) SWIG_fail;
40108 {
40109 PyThreadState* __tstate = wxPyBeginAllowThreads();
40110 (arg1)->Layout();
40111
40112 wxPyEndAllowThreads(__tstate);
40113 if (PyErr_Occurred()) SWIG_fail;
40114 }
40115 Py_INCREF(Py_None); resultobj = Py_None;
40116 return resultobj;
40117 fail:
40118 return NULL;
40119 }
40120
40121
40122 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40123 PyObject *resultobj;
40124 wxSizer *arg1 = (wxSizer *) 0 ;
40125 wxWindow *arg2 = (wxWindow *) 0 ;
40126 wxSize result;
40127 PyObject * obj0 = 0 ;
40128 PyObject * obj1 = 0 ;
40129 char *kwnames[] = {
40130 (char *) "self",(char *) "window", NULL
40131 };
40132
40133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40135 if (SWIG_arg_fail(1)) SWIG_fail;
40136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40137 if (SWIG_arg_fail(2)) SWIG_fail;
40138 {
40139 PyThreadState* __tstate = wxPyBeginAllowThreads();
40140 result = (arg1)->Fit(arg2);
40141
40142 wxPyEndAllowThreads(__tstate);
40143 if (PyErr_Occurred()) SWIG_fail;
40144 }
40145 {
40146 wxSize * resultptr;
40147 resultptr = new wxSize((wxSize &)(result));
40148 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40149 }
40150 return resultobj;
40151 fail:
40152 return NULL;
40153 }
40154
40155
40156 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40157 PyObject *resultobj;
40158 wxSizer *arg1 = (wxSizer *) 0 ;
40159 wxWindow *arg2 = (wxWindow *) 0 ;
40160 PyObject * obj0 = 0 ;
40161 PyObject * obj1 = 0 ;
40162 char *kwnames[] = {
40163 (char *) "self",(char *) "window", NULL
40164 };
40165
40166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40168 if (SWIG_arg_fail(1)) SWIG_fail;
40169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40170 if (SWIG_arg_fail(2)) SWIG_fail;
40171 {
40172 PyThreadState* __tstate = wxPyBeginAllowThreads();
40173 (arg1)->FitInside(arg2);
40174
40175 wxPyEndAllowThreads(__tstate);
40176 if (PyErr_Occurred()) SWIG_fail;
40177 }
40178 Py_INCREF(Py_None); resultobj = Py_None;
40179 return resultobj;
40180 fail:
40181 return NULL;
40182 }
40183
40184
40185 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40186 PyObject *resultobj;
40187 wxSizer *arg1 = (wxSizer *) 0 ;
40188 wxWindow *arg2 = (wxWindow *) 0 ;
40189 PyObject * obj0 = 0 ;
40190 PyObject * obj1 = 0 ;
40191 char *kwnames[] = {
40192 (char *) "self",(char *) "window", NULL
40193 };
40194
40195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40197 if (SWIG_arg_fail(1)) SWIG_fail;
40198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40199 if (SWIG_arg_fail(2)) SWIG_fail;
40200 {
40201 PyThreadState* __tstate = wxPyBeginAllowThreads();
40202 (arg1)->SetSizeHints(arg2);
40203
40204 wxPyEndAllowThreads(__tstate);
40205 if (PyErr_Occurred()) SWIG_fail;
40206 }
40207 Py_INCREF(Py_None); resultobj = Py_None;
40208 return resultobj;
40209 fail:
40210 return NULL;
40211 }
40212
40213
40214 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40215 PyObject *resultobj;
40216 wxSizer *arg1 = (wxSizer *) 0 ;
40217 wxWindow *arg2 = (wxWindow *) 0 ;
40218 PyObject * obj0 = 0 ;
40219 PyObject * obj1 = 0 ;
40220 char *kwnames[] = {
40221 (char *) "self",(char *) "window", NULL
40222 };
40223
40224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40226 if (SWIG_arg_fail(1)) SWIG_fail;
40227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40228 if (SWIG_arg_fail(2)) SWIG_fail;
40229 {
40230 PyThreadState* __tstate = wxPyBeginAllowThreads();
40231 (arg1)->SetVirtualSizeHints(arg2);
40232
40233 wxPyEndAllowThreads(__tstate);
40234 if (PyErr_Occurred()) SWIG_fail;
40235 }
40236 Py_INCREF(Py_None); resultobj = Py_None;
40237 return resultobj;
40238 fail:
40239 return NULL;
40240 }
40241
40242
40243 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40244 PyObject *resultobj;
40245 wxSizer *arg1 = (wxSizer *) 0 ;
40246 bool arg2 = (bool) false ;
40247 PyObject * obj0 = 0 ;
40248 PyObject * obj1 = 0 ;
40249 char *kwnames[] = {
40250 (char *) "self",(char *) "deleteWindows", NULL
40251 };
40252
40253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40255 if (SWIG_arg_fail(1)) SWIG_fail;
40256 if (obj1) {
40257 {
40258 arg2 = (bool)(SWIG_As_bool(obj1));
40259 if (SWIG_arg_fail(2)) SWIG_fail;
40260 }
40261 }
40262 {
40263 PyThreadState* __tstate = wxPyBeginAllowThreads();
40264 (arg1)->Clear(arg2);
40265
40266 wxPyEndAllowThreads(__tstate);
40267 if (PyErr_Occurred()) SWIG_fail;
40268 }
40269 Py_INCREF(Py_None); resultobj = Py_None;
40270 return resultobj;
40271 fail:
40272 return NULL;
40273 }
40274
40275
40276 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40277 PyObject *resultobj;
40278 wxSizer *arg1 = (wxSizer *) 0 ;
40279 PyObject * obj0 = 0 ;
40280 char *kwnames[] = {
40281 (char *) "self", NULL
40282 };
40283
40284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40286 if (SWIG_arg_fail(1)) SWIG_fail;
40287 {
40288 PyThreadState* __tstate = wxPyBeginAllowThreads();
40289 (arg1)->DeleteWindows();
40290
40291 wxPyEndAllowThreads(__tstate);
40292 if (PyErr_Occurred()) SWIG_fail;
40293 }
40294 Py_INCREF(Py_None); resultobj = Py_None;
40295 return resultobj;
40296 fail:
40297 return NULL;
40298 }
40299
40300
40301 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40302 PyObject *resultobj;
40303 wxSizer *arg1 = (wxSizer *) 0 ;
40304 PyObject *result;
40305 PyObject * obj0 = 0 ;
40306 char *kwnames[] = {
40307 (char *) "self", NULL
40308 };
40309
40310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40312 if (SWIG_arg_fail(1)) SWIG_fail;
40313 {
40314 PyThreadState* __tstate = wxPyBeginAllowThreads();
40315 result = (PyObject *)wxSizer_GetChildren(arg1);
40316
40317 wxPyEndAllowThreads(__tstate);
40318 if (PyErr_Occurred()) SWIG_fail;
40319 }
40320 resultobj = result;
40321 return resultobj;
40322 fail:
40323 return NULL;
40324 }
40325
40326
40327 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40328 PyObject *resultobj;
40329 wxSizer *arg1 = (wxSizer *) 0 ;
40330 PyObject *arg2 = (PyObject *) 0 ;
40331 bool arg3 = (bool) true ;
40332 bool arg4 = (bool) false ;
40333 bool result;
40334 PyObject * obj0 = 0 ;
40335 PyObject * obj1 = 0 ;
40336 PyObject * obj2 = 0 ;
40337 PyObject * obj3 = 0 ;
40338 char *kwnames[] = {
40339 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40340 };
40341
40342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40344 if (SWIG_arg_fail(1)) SWIG_fail;
40345 arg2 = obj1;
40346 if (obj2) {
40347 {
40348 arg3 = (bool)(SWIG_As_bool(obj2));
40349 if (SWIG_arg_fail(3)) SWIG_fail;
40350 }
40351 }
40352 if (obj3) {
40353 {
40354 arg4 = (bool)(SWIG_As_bool(obj3));
40355 if (SWIG_arg_fail(4)) SWIG_fail;
40356 }
40357 }
40358 {
40359 PyThreadState* __tstate = wxPyBeginAllowThreads();
40360 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40361
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 {
40366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40367 }
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj;
40376 wxSizer *arg1 = (wxSizer *) 0 ;
40377 PyObject *arg2 = (PyObject *) 0 ;
40378 bool result;
40379 PyObject * obj0 = 0 ;
40380 PyObject * obj1 = 0 ;
40381 char *kwnames[] = {
40382 (char *) "self",(char *) "item", NULL
40383 };
40384
40385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40387 if (SWIG_arg_fail(1)) SWIG_fail;
40388 arg2 = obj1;
40389 {
40390 PyThreadState* __tstate = wxPyBeginAllowThreads();
40391 result = (bool)wxSizer_IsShown(arg1,arg2);
40392
40393 wxPyEndAllowThreads(__tstate);
40394 if (PyErr_Occurred()) SWIG_fail;
40395 }
40396 {
40397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40398 }
40399 return resultobj;
40400 fail:
40401 return NULL;
40402 }
40403
40404
40405 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40406 PyObject *resultobj;
40407 wxSizer *arg1 = (wxSizer *) 0 ;
40408 bool arg2 ;
40409 PyObject * obj0 = 0 ;
40410 PyObject * obj1 = 0 ;
40411 char *kwnames[] = {
40412 (char *) "self",(char *) "show", NULL
40413 };
40414
40415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40417 if (SWIG_arg_fail(1)) SWIG_fail;
40418 {
40419 arg2 = (bool)(SWIG_As_bool(obj1));
40420 if (SWIG_arg_fail(2)) SWIG_fail;
40421 }
40422 {
40423 PyThreadState* __tstate = wxPyBeginAllowThreads();
40424 (arg1)->ShowItems(arg2);
40425
40426 wxPyEndAllowThreads(__tstate);
40427 if (PyErr_Occurred()) SWIG_fail;
40428 }
40429 Py_INCREF(Py_None); resultobj = Py_None;
40430 return resultobj;
40431 fail:
40432 return NULL;
40433 }
40434
40435
40436 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40437 PyObject *obj;
40438 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40439 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40440 Py_INCREF(obj);
40441 return Py_BuildValue((char *)"");
40442 }
40443 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40444 PyObject *resultobj;
40445 wxPySizer *result;
40446 char *kwnames[] = {
40447 NULL
40448 };
40449
40450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 result = (wxPySizer *)new wxPySizer();
40454
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40459 return resultobj;
40460 fail:
40461 return NULL;
40462 }
40463
40464
40465 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40466 PyObject *resultobj;
40467 wxPySizer *arg1 = (wxPySizer *) 0 ;
40468 PyObject *arg2 = (PyObject *) 0 ;
40469 PyObject *arg3 = (PyObject *) 0 ;
40470 PyObject * obj0 = 0 ;
40471 PyObject * obj1 = 0 ;
40472 PyObject * obj2 = 0 ;
40473 char *kwnames[] = {
40474 (char *) "self",(char *) "self",(char *) "_class", NULL
40475 };
40476
40477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40479 if (SWIG_arg_fail(1)) SWIG_fail;
40480 arg2 = obj1;
40481 arg3 = obj2;
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 (arg1)->_setCallbackInfo(arg2,arg3);
40485
40486 wxPyEndAllowThreads(__tstate);
40487 if (PyErr_Occurred()) SWIG_fail;
40488 }
40489 Py_INCREF(Py_None); resultobj = Py_None;
40490 return resultobj;
40491 fail:
40492 return NULL;
40493 }
40494
40495
40496 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40497 PyObject *obj;
40498 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40499 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40500 Py_INCREF(obj);
40501 return Py_BuildValue((char *)"");
40502 }
40503 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40504 PyObject *resultobj;
40505 int arg1 = (int) wxHORIZONTAL ;
40506 wxBoxSizer *result;
40507 PyObject * obj0 = 0 ;
40508 char *kwnames[] = {
40509 (char *) "orient", NULL
40510 };
40511
40512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40513 if (obj0) {
40514 {
40515 arg1 = (int)(SWIG_As_int(obj0));
40516 if (SWIG_arg_fail(1)) SWIG_fail;
40517 }
40518 }
40519 {
40520 PyThreadState* __tstate = wxPyBeginAllowThreads();
40521 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40522
40523 wxPyEndAllowThreads(__tstate);
40524 if (PyErr_Occurred()) SWIG_fail;
40525 }
40526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40534 PyObject *resultobj;
40535 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40536 int result;
40537 PyObject * obj0 = 0 ;
40538 char *kwnames[] = {
40539 (char *) "self", NULL
40540 };
40541
40542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40544 if (SWIG_arg_fail(1)) SWIG_fail;
40545 {
40546 PyThreadState* __tstate = wxPyBeginAllowThreads();
40547 result = (int)(arg1)->GetOrientation();
40548
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 {
40553 resultobj = SWIG_From_int((int)(result));
40554 }
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40562 PyObject *resultobj;
40563 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40564 int arg2 ;
40565 PyObject * obj0 = 0 ;
40566 PyObject * obj1 = 0 ;
40567 char *kwnames[] = {
40568 (char *) "self",(char *) "orient", NULL
40569 };
40570
40571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40573 if (SWIG_arg_fail(1)) SWIG_fail;
40574 {
40575 arg2 = (int)(SWIG_As_int(obj1));
40576 if (SWIG_arg_fail(2)) SWIG_fail;
40577 }
40578 {
40579 PyThreadState* __tstate = wxPyBeginAllowThreads();
40580 (arg1)->SetOrientation(arg2);
40581
40582 wxPyEndAllowThreads(__tstate);
40583 if (PyErr_Occurred()) SWIG_fail;
40584 }
40585 Py_INCREF(Py_None); resultobj = Py_None;
40586 return resultobj;
40587 fail:
40588 return NULL;
40589 }
40590
40591
40592 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40593 PyObject *obj;
40594 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40595 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40596 Py_INCREF(obj);
40597 return Py_BuildValue((char *)"");
40598 }
40599 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40600 PyObject *resultobj;
40601 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40602 int arg2 = (int) wxHORIZONTAL ;
40603 wxStaticBoxSizer *result;
40604 PyObject * obj0 = 0 ;
40605 PyObject * obj1 = 0 ;
40606 char *kwnames[] = {
40607 (char *) "box",(char *) "orient", NULL
40608 };
40609
40610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40612 if (SWIG_arg_fail(1)) SWIG_fail;
40613 if (obj1) {
40614 {
40615 arg2 = (int)(SWIG_As_int(obj1));
40616 if (SWIG_arg_fail(2)) SWIG_fail;
40617 }
40618 }
40619 {
40620 PyThreadState* __tstate = wxPyBeginAllowThreads();
40621 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40622
40623 wxPyEndAllowThreads(__tstate);
40624 if (PyErr_Occurred()) SWIG_fail;
40625 }
40626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40634 PyObject *resultobj;
40635 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40636 wxStaticBox *result;
40637 PyObject * obj0 = 0 ;
40638 char *kwnames[] = {
40639 (char *) "self", NULL
40640 };
40641
40642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40644 if (SWIG_arg_fail(1)) SWIG_fail;
40645 {
40646 PyThreadState* __tstate = wxPyBeginAllowThreads();
40647 result = (wxStaticBox *)(arg1)->GetStaticBox();
40648
40649 wxPyEndAllowThreads(__tstate);
40650 if (PyErr_Occurred()) SWIG_fail;
40651 }
40652 {
40653 resultobj = wxPyMake_wxObject(result, 0);
40654 }
40655 return resultobj;
40656 fail:
40657 return NULL;
40658 }
40659
40660
40661 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40662 PyObject *obj;
40663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40664 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40665 Py_INCREF(obj);
40666 return Py_BuildValue((char *)"");
40667 }
40668 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40669 PyObject *resultobj;
40670 int arg1 = (int) 1 ;
40671 int arg2 = (int) 0 ;
40672 int arg3 = (int) 0 ;
40673 int arg4 = (int) 0 ;
40674 wxGridSizer *result;
40675 PyObject * obj0 = 0 ;
40676 PyObject * obj1 = 0 ;
40677 PyObject * obj2 = 0 ;
40678 PyObject * obj3 = 0 ;
40679 char *kwnames[] = {
40680 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40681 };
40682
40683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40684 if (obj0) {
40685 {
40686 arg1 = (int)(SWIG_As_int(obj0));
40687 if (SWIG_arg_fail(1)) SWIG_fail;
40688 }
40689 }
40690 if (obj1) {
40691 {
40692 arg2 = (int)(SWIG_As_int(obj1));
40693 if (SWIG_arg_fail(2)) SWIG_fail;
40694 }
40695 }
40696 if (obj2) {
40697 {
40698 arg3 = (int)(SWIG_As_int(obj2));
40699 if (SWIG_arg_fail(3)) SWIG_fail;
40700 }
40701 }
40702 if (obj3) {
40703 {
40704 arg4 = (int)(SWIG_As_int(obj3));
40705 if (SWIG_arg_fail(4)) SWIG_fail;
40706 }
40707 }
40708 {
40709 PyThreadState* __tstate = wxPyBeginAllowThreads();
40710 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40711
40712 wxPyEndAllowThreads(__tstate);
40713 if (PyErr_Occurred()) SWIG_fail;
40714 }
40715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40716 return resultobj;
40717 fail:
40718 return NULL;
40719 }
40720
40721
40722 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40723 PyObject *resultobj;
40724 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40725 int arg2 ;
40726 PyObject * obj0 = 0 ;
40727 PyObject * obj1 = 0 ;
40728 char *kwnames[] = {
40729 (char *) "self",(char *) "cols", NULL
40730 };
40731
40732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40734 if (SWIG_arg_fail(1)) SWIG_fail;
40735 {
40736 arg2 = (int)(SWIG_As_int(obj1));
40737 if (SWIG_arg_fail(2)) SWIG_fail;
40738 }
40739 {
40740 PyThreadState* __tstate = wxPyBeginAllowThreads();
40741 (arg1)->SetCols(arg2);
40742
40743 wxPyEndAllowThreads(__tstate);
40744 if (PyErr_Occurred()) SWIG_fail;
40745 }
40746 Py_INCREF(Py_None); resultobj = Py_None;
40747 return resultobj;
40748 fail:
40749 return NULL;
40750 }
40751
40752
40753 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40754 PyObject *resultobj;
40755 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40756 int arg2 ;
40757 PyObject * obj0 = 0 ;
40758 PyObject * obj1 = 0 ;
40759 char *kwnames[] = {
40760 (char *) "self",(char *) "rows", NULL
40761 };
40762
40763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40765 if (SWIG_arg_fail(1)) SWIG_fail;
40766 {
40767 arg2 = (int)(SWIG_As_int(obj1));
40768 if (SWIG_arg_fail(2)) SWIG_fail;
40769 }
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 (arg1)->SetRows(arg2);
40773
40774 wxPyEndAllowThreads(__tstate);
40775 if (PyErr_Occurred()) SWIG_fail;
40776 }
40777 Py_INCREF(Py_None); resultobj = Py_None;
40778 return resultobj;
40779 fail:
40780 return NULL;
40781 }
40782
40783
40784 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40785 PyObject *resultobj;
40786 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40787 int arg2 ;
40788 PyObject * obj0 = 0 ;
40789 PyObject * obj1 = 0 ;
40790 char *kwnames[] = {
40791 (char *) "self",(char *) "gap", NULL
40792 };
40793
40794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40796 if (SWIG_arg_fail(1)) SWIG_fail;
40797 {
40798 arg2 = (int)(SWIG_As_int(obj1));
40799 if (SWIG_arg_fail(2)) SWIG_fail;
40800 }
40801 {
40802 PyThreadState* __tstate = wxPyBeginAllowThreads();
40803 (arg1)->SetVGap(arg2);
40804
40805 wxPyEndAllowThreads(__tstate);
40806 if (PyErr_Occurred()) SWIG_fail;
40807 }
40808 Py_INCREF(Py_None); resultobj = Py_None;
40809 return resultobj;
40810 fail:
40811 return NULL;
40812 }
40813
40814
40815 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40816 PyObject *resultobj;
40817 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40818 int arg2 ;
40819 PyObject * obj0 = 0 ;
40820 PyObject * obj1 = 0 ;
40821 char *kwnames[] = {
40822 (char *) "self",(char *) "gap", NULL
40823 };
40824
40825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40827 if (SWIG_arg_fail(1)) SWIG_fail;
40828 {
40829 arg2 = (int)(SWIG_As_int(obj1));
40830 if (SWIG_arg_fail(2)) SWIG_fail;
40831 }
40832 {
40833 PyThreadState* __tstate = wxPyBeginAllowThreads();
40834 (arg1)->SetHGap(arg2);
40835
40836 wxPyEndAllowThreads(__tstate);
40837 if (PyErr_Occurred()) SWIG_fail;
40838 }
40839 Py_INCREF(Py_None); resultobj = Py_None;
40840 return resultobj;
40841 fail:
40842 return NULL;
40843 }
40844
40845
40846 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40847 PyObject *resultobj;
40848 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40849 int result;
40850 PyObject * obj0 = 0 ;
40851 char *kwnames[] = {
40852 (char *) "self", NULL
40853 };
40854
40855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40857 if (SWIG_arg_fail(1)) SWIG_fail;
40858 {
40859 PyThreadState* __tstate = wxPyBeginAllowThreads();
40860 result = (int)(arg1)->GetCols();
40861
40862 wxPyEndAllowThreads(__tstate);
40863 if (PyErr_Occurred()) SWIG_fail;
40864 }
40865 {
40866 resultobj = SWIG_From_int((int)(result));
40867 }
40868 return resultobj;
40869 fail:
40870 return NULL;
40871 }
40872
40873
40874 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40875 PyObject *resultobj;
40876 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40877 int result;
40878 PyObject * obj0 = 0 ;
40879 char *kwnames[] = {
40880 (char *) "self", NULL
40881 };
40882
40883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40885 if (SWIG_arg_fail(1)) SWIG_fail;
40886 {
40887 PyThreadState* __tstate = wxPyBeginAllowThreads();
40888 result = (int)(arg1)->GetRows();
40889
40890 wxPyEndAllowThreads(__tstate);
40891 if (PyErr_Occurred()) SWIG_fail;
40892 }
40893 {
40894 resultobj = SWIG_From_int((int)(result));
40895 }
40896 return resultobj;
40897 fail:
40898 return NULL;
40899 }
40900
40901
40902 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40903 PyObject *resultobj;
40904 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40905 int result;
40906 PyObject * obj0 = 0 ;
40907 char *kwnames[] = {
40908 (char *) "self", NULL
40909 };
40910
40911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40913 if (SWIG_arg_fail(1)) SWIG_fail;
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 result = (int)(arg1)->GetVGap();
40917
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 {
40922 resultobj = SWIG_From_int((int)(result));
40923 }
40924 return resultobj;
40925 fail:
40926 return NULL;
40927 }
40928
40929
40930 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40931 PyObject *resultobj;
40932 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40933 int result;
40934 PyObject * obj0 = 0 ;
40935 char *kwnames[] = {
40936 (char *) "self", NULL
40937 };
40938
40939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40941 if (SWIG_arg_fail(1)) SWIG_fail;
40942 {
40943 PyThreadState* __tstate = wxPyBeginAllowThreads();
40944 result = (int)(arg1)->GetHGap();
40945
40946 wxPyEndAllowThreads(__tstate);
40947 if (PyErr_Occurred()) SWIG_fail;
40948 }
40949 {
40950 resultobj = SWIG_From_int((int)(result));
40951 }
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40959 PyObject *obj;
40960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40961 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40962 Py_INCREF(obj);
40963 return Py_BuildValue((char *)"");
40964 }
40965 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40966 PyObject *resultobj;
40967 int arg1 = (int) 1 ;
40968 int arg2 = (int) 0 ;
40969 int arg3 = (int) 0 ;
40970 int arg4 = (int) 0 ;
40971 wxFlexGridSizer *result;
40972 PyObject * obj0 = 0 ;
40973 PyObject * obj1 = 0 ;
40974 PyObject * obj2 = 0 ;
40975 PyObject * obj3 = 0 ;
40976 char *kwnames[] = {
40977 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40978 };
40979
40980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40981 if (obj0) {
40982 {
40983 arg1 = (int)(SWIG_As_int(obj0));
40984 if (SWIG_arg_fail(1)) SWIG_fail;
40985 }
40986 }
40987 if (obj1) {
40988 {
40989 arg2 = (int)(SWIG_As_int(obj1));
40990 if (SWIG_arg_fail(2)) SWIG_fail;
40991 }
40992 }
40993 if (obj2) {
40994 {
40995 arg3 = (int)(SWIG_As_int(obj2));
40996 if (SWIG_arg_fail(3)) SWIG_fail;
40997 }
40998 }
40999 if (obj3) {
41000 {
41001 arg4 = (int)(SWIG_As_int(obj3));
41002 if (SWIG_arg_fail(4)) SWIG_fail;
41003 }
41004 }
41005 {
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41008
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj;
41021 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41022 size_t arg2 ;
41023 int arg3 = (int) 0 ;
41024 PyObject * obj0 = 0 ;
41025 PyObject * obj1 = 0 ;
41026 PyObject * obj2 = 0 ;
41027 char *kwnames[] = {
41028 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41029 };
41030
41031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41033 if (SWIG_arg_fail(1)) SWIG_fail;
41034 {
41035 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41036 if (SWIG_arg_fail(2)) SWIG_fail;
41037 }
41038 if (obj2) {
41039 {
41040 arg3 = (int)(SWIG_As_int(obj2));
41041 if (SWIG_arg_fail(3)) SWIG_fail;
41042 }
41043 }
41044 {
41045 PyThreadState* __tstate = wxPyBeginAllowThreads();
41046 (arg1)->AddGrowableRow(arg2,arg3);
41047
41048 wxPyEndAllowThreads(__tstate);
41049 if (PyErr_Occurred()) SWIG_fail;
41050 }
41051 Py_INCREF(Py_None); resultobj = Py_None;
41052 return resultobj;
41053 fail:
41054 return NULL;
41055 }
41056
41057
41058 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41059 PyObject *resultobj;
41060 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41061 size_t arg2 ;
41062 PyObject * obj0 = 0 ;
41063 PyObject * obj1 = 0 ;
41064 char *kwnames[] = {
41065 (char *) "self",(char *) "idx", NULL
41066 };
41067
41068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41070 if (SWIG_arg_fail(1)) SWIG_fail;
41071 {
41072 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41073 if (SWIG_arg_fail(2)) SWIG_fail;
41074 }
41075 {
41076 PyThreadState* __tstate = wxPyBeginAllowThreads();
41077 (arg1)->RemoveGrowableRow(arg2);
41078
41079 wxPyEndAllowThreads(__tstate);
41080 if (PyErr_Occurred()) SWIG_fail;
41081 }
41082 Py_INCREF(Py_None); resultobj = Py_None;
41083 return resultobj;
41084 fail:
41085 return NULL;
41086 }
41087
41088
41089 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41090 PyObject *resultobj;
41091 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41092 size_t arg2 ;
41093 int arg3 = (int) 0 ;
41094 PyObject * obj0 = 0 ;
41095 PyObject * obj1 = 0 ;
41096 PyObject * obj2 = 0 ;
41097 char *kwnames[] = {
41098 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41099 };
41100
41101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41103 if (SWIG_arg_fail(1)) SWIG_fail;
41104 {
41105 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41106 if (SWIG_arg_fail(2)) SWIG_fail;
41107 }
41108 if (obj2) {
41109 {
41110 arg3 = (int)(SWIG_As_int(obj2));
41111 if (SWIG_arg_fail(3)) SWIG_fail;
41112 }
41113 }
41114 {
41115 PyThreadState* __tstate = wxPyBeginAllowThreads();
41116 (arg1)->AddGrowableCol(arg2,arg3);
41117
41118 wxPyEndAllowThreads(__tstate);
41119 if (PyErr_Occurred()) SWIG_fail;
41120 }
41121 Py_INCREF(Py_None); resultobj = Py_None;
41122 return resultobj;
41123 fail:
41124 return NULL;
41125 }
41126
41127
41128 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41129 PyObject *resultobj;
41130 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41131 size_t arg2 ;
41132 PyObject * obj0 = 0 ;
41133 PyObject * obj1 = 0 ;
41134 char *kwnames[] = {
41135 (char *) "self",(char *) "idx", NULL
41136 };
41137
41138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41140 if (SWIG_arg_fail(1)) SWIG_fail;
41141 {
41142 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41143 if (SWIG_arg_fail(2)) SWIG_fail;
41144 }
41145 {
41146 PyThreadState* __tstate = wxPyBeginAllowThreads();
41147 (arg1)->RemoveGrowableCol(arg2);
41148
41149 wxPyEndAllowThreads(__tstate);
41150 if (PyErr_Occurred()) SWIG_fail;
41151 }
41152 Py_INCREF(Py_None); resultobj = Py_None;
41153 return resultobj;
41154 fail:
41155 return NULL;
41156 }
41157
41158
41159 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41160 PyObject *resultobj;
41161 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41162 int arg2 ;
41163 PyObject * obj0 = 0 ;
41164 PyObject * obj1 = 0 ;
41165 char *kwnames[] = {
41166 (char *) "self",(char *) "direction", NULL
41167 };
41168
41169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41171 if (SWIG_arg_fail(1)) SWIG_fail;
41172 {
41173 arg2 = (int)(SWIG_As_int(obj1));
41174 if (SWIG_arg_fail(2)) SWIG_fail;
41175 }
41176 {
41177 PyThreadState* __tstate = wxPyBeginAllowThreads();
41178 (arg1)->SetFlexibleDirection(arg2);
41179
41180 wxPyEndAllowThreads(__tstate);
41181 if (PyErr_Occurred()) SWIG_fail;
41182 }
41183 Py_INCREF(Py_None); resultobj = Py_None;
41184 return resultobj;
41185 fail:
41186 return NULL;
41187 }
41188
41189
41190 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41191 PyObject *resultobj;
41192 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41193 int result;
41194 PyObject * obj0 = 0 ;
41195 char *kwnames[] = {
41196 (char *) "self", NULL
41197 };
41198
41199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41201 if (SWIG_arg_fail(1)) SWIG_fail;
41202 {
41203 PyThreadState* __tstate = wxPyBeginAllowThreads();
41204 result = (int)(arg1)->GetFlexibleDirection();
41205
41206 wxPyEndAllowThreads(__tstate);
41207 if (PyErr_Occurred()) SWIG_fail;
41208 }
41209 {
41210 resultobj = SWIG_From_int((int)(result));
41211 }
41212 return resultobj;
41213 fail:
41214 return NULL;
41215 }
41216
41217
41218 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41219 PyObject *resultobj;
41220 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41221 wxFlexSizerGrowMode arg2 ;
41222 PyObject * obj0 = 0 ;
41223 PyObject * obj1 = 0 ;
41224 char *kwnames[] = {
41225 (char *) "self",(char *) "mode", NULL
41226 };
41227
41228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41230 if (SWIG_arg_fail(1)) SWIG_fail;
41231 {
41232 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41233 if (SWIG_arg_fail(2)) SWIG_fail;
41234 }
41235 {
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41238
41239 wxPyEndAllowThreads(__tstate);
41240 if (PyErr_Occurred()) SWIG_fail;
41241 }
41242 Py_INCREF(Py_None); resultobj = Py_None;
41243 return resultobj;
41244 fail:
41245 return NULL;
41246 }
41247
41248
41249 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41250 PyObject *resultobj;
41251 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41252 wxFlexSizerGrowMode result;
41253 PyObject * obj0 = 0 ;
41254 char *kwnames[] = {
41255 (char *) "self", NULL
41256 };
41257
41258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41260 if (SWIG_arg_fail(1)) SWIG_fail;
41261 {
41262 PyThreadState* __tstate = wxPyBeginAllowThreads();
41263 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41264
41265 wxPyEndAllowThreads(__tstate);
41266 if (PyErr_Occurred()) SWIG_fail;
41267 }
41268 resultobj = SWIG_From_int((result));
41269 return resultobj;
41270 fail:
41271 return NULL;
41272 }
41273
41274
41275 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41276 PyObject *resultobj;
41277 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41278 wxArrayInt *result;
41279 PyObject * obj0 = 0 ;
41280 char *kwnames[] = {
41281 (char *) "self", NULL
41282 };
41283
41284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41286 if (SWIG_arg_fail(1)) SWIG_fail;
41287 {
41288 PyThreadState* __tstate = wxPyBeginAllowThreads();
41289 {
41290 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41291 result = (wxArrayInt *) &_result_ref;
41292 }
41293
41294 wxPyEndAllowThreads(__tstate);
41295 if (PyErr_Occurred()) SWIG_fail;
41296 }
41297 {
41298 resultobj = PyList_New(0);
41299 size_t idx;
41300 for (idx = 0; idx < result->GetCount(); idx += 1) {
41301 PyObject* val = PyInt_FromLong( result->Item(idx) );
41302 PyList_Append(resultobj, val);
41303 Py_DECREF(val);
41304 }
41305 }
41306 return resultobj;
41307 fail:
41308 return NULL;
41309 }
41310
41311
41312 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41313 PyObject *resultobj;
41314 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41315 wxArrayInt *result;
41316 PyObject * obj0 = 0 ;
41317 char *kwnames[] = {
41318 (char *) "self", NULL
41319 };
41320
41321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41323 if (SWIG_arg_fail(1)) SWIG_fail;
41324 {
41325 PyThreadState* __tstate = wxPyBeginAllowThreads();
41326 {
41327 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41328 result = (wxArrayInt *) &_result_ref;
41329 }
41330
41331 wxPyEndAllowThreads(__tstate);
41332 if (PyErr_Occurred()) SWIG_fail;
41333 }
41334 {
41335 resultobj = PyList_New(0);
41336 size_t idx;
41337 for (idx = 0; idx < result->GetCount(); idx += 1) {
41338 PyObject* val = PyInt_FromLong( result->Item(idx) );
41339 PyList_Append(resultobj, val);
41340 Py_DECREF(val);
41341 }
41342 }
41343 return resultobj;
41344 fail:
41345 return NULL;
41346 }
41347
41348
41349 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41350 PyObject *obj;
41351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41352 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41353 Py_INCREF(obj);
41354 return Py_BuildValue((char *)"");
41355 }
41356 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41357 PyObject *resultobj;
41358 wxStdDialogButtonSizer *result;
41359 char *kwnames[] = {
41360 NULL
41361 };
41362
41363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41364 {
41365 PyThreadState* __tstate = wxPyBeginAllowThreads();
41366 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41367
41368 wxPyEndAllowThreads(__tstate);
41369 if (PyErr_Occurred()) SWIG_fail;
41370 }
41371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41372 return resultobj;
41373 fail:
41374 return NULL;
41375 }
41376
41377
41378 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41379 PyObject *resultobj;
41380 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41381 wxButton *arg2 = (wxButton *) 0 ;
41382 PyObject * obj0 = 0 ;
41383 PyObject * obj1 = 0 ;
41384 char *kwnames[] = {
41385 (char *) "self",(char *) "button", NULL
41386 };
41387
41388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41390 if (SWIG_arg_fail(1)) SWIG_fail;
41391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41392 if (SWIG_arg_fail(2)) SWIG_fail;
41393 {
41394 PyThreadState* __tstate = wxPyBeginAllowThreads();
41395 (arg1)->AddButton(arg2);
41396
41397 wxPyEndAllowThreads(__tstate);
41398 if (PyErr_Occurred()) SWIG_fail;
41399 }
41400 Py_INCREF(Py_None); resultobj = Py_None;
41401 return resultobj;
41402 fail:
41403 return NULL;
41404 }
41405
41406
41407 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41408 PyObject *resultobj;
41409 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41410 PyObject * obj0 = 0 ;
41411 char *kwnames[] = {
41412 (char *) "self", NULL
41413 };
41414
41415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41417 if (SWIG_arg_fail(1)) SWIG_fail;
41418 {
41419 PyThreadState* __tstate = wxPyBeginAllowThreads();
41420 (arg1)->Realize();
41421
41422 wxPyEndAllowThreads(__tstate);
41423 if (PyErr_Occurred()) SWIG_fail;
41424 }
41425 Py_INCREF(Py_None); resultobj = Py_None;
41426 return resultobj;
41427 fail:
41428 return NULL;
41429 }
41430
41431
41432 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41433 PyObject *resultobj;
41434 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41435 wxButton *arg2 = (wxButton *) 0 ;
41436 PyObject * obj0 = 0 ;
41437 PyObject * obj1 = 0 ;
41438 char *kwnames[] = {
41439 (char *) "self",(char *) "button", NULL
41440 };
41441
41442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41444 if (SWIG_arg_fail(1)) SWIG_fail;
41445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41446 if (SWIG_arg_fail(2)) SWIG_fail;
41447 {
41448 PyThreadState* __tstate = wxPyBeginAllowThreads();
41449 (arg1)->SetAffirmativeButton(arg2);
41450
41451 wxPyEndAllowThreads(__tstate);
41452 if (PyErr_Occurred()) SWIG_fail;
41453 }
41454 Py_INCREF(Py_None); resultobj = Py_None;
41455 return resultobj;
41456 fail:
41457 return NULL;
41458 }
41459
41460
41461 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41462 PyObject *resultobj;
41463 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41464 wxButton *arg2 = (wxButton *) 0 ;
41465 PyObject * obj0 = 0 ;
41466 PyObject * obj1 = 0 ;
41467 char *kwnames[] = {
41468 (char *) "self",(char *) "button", NULL
41469 };
41470
41471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41473 if (SWIG_arg_fail(1)) SWIG_fail;
41474 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41475 if (SWIG_arg_fail(2)) SWIG_fail;
41476 {
41477 PyThreadState* __tstate = wxPyBeginAllowThreads();
41478 (arg1)->SetNegativeButton(arg2);
41479
41480 wxPyEndAllowThreads(__tstate);
41481 if (PyErr_Occurred()) SWIG_fail;
41482 }
41483 Py_INCREF(Py_None); resultobj = Py_None;
41484 return resultobj;
41485 fail:
41486 return NULL;
41487 }
41488
41489
41490 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41491 PyObject *resultobj;
41492 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41493 wxButton *arg2 = (wxButton *) 0 ;
41494 PyObject * obj0 = 0 ;
41495 PyObject * obj1 = 0 ;
41496 char *kwnames[] = {
41497 (char *) "self",(char *) "button", NULL
41498 };
41499
41500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41502 if (SWIG_arg_fail(1)) SWIG_fail;
41503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41504 if (SWIG_arg_fail(2)) SWIG_fail;
41505 {
41506 PyThreadState* __tstate = wxPyBeginAllowThreads();
41507 (arg1)->SetCancelButton(arg2);
41508
41509 wxPyEndAllowThreads(__tstate);
41510 if (PyErr_Occurred()) SWIG_fail;
41511 }
41512 Py_INCREF(Py_None); resultobj = Py_None;
41513 return resultobj;
41514 fail:
41515 return NULL;
41516 }
41517
41518
41519 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41520 PyObject *resultobj;
41521 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41522 wxButton *result;
41523 PyObject * obj0 = 0 ;
41524 char *kwnames[] = {
41525 (char *) "self", NULL
41526 };
41527
41528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41530 if (SWIG_arg_fail(1)) SWIG_fail;
41531 {
41532 PyThreadState* __tstate = wxPyBeginAllowThreads();
41533 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41534
41535 wxPyEndAllowThreads(__tstate);
41536 if (PyErr_Occurred()) SWIG_fail;
41537 }
41538 {
41539 resultobj = wxPyMake_wxObject(result, 0);
41540 }
41541 return resultobj;
41542 fail:
41543 return NULL;
41544 }
41545
41546
41547 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41548 PyObject *resultobj;
41549 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41550 wxButton *result;
41551 PyObject * obj0 = 0 ;
41552 char *kwnames[] = {
41553 (char *) "self", NULL
41554 };
41555
41556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41558 if (SWIG_arg_fail(1)) SWIG_fail;
41559 {
41560 PyThreadState* __tstate = wxPyBeginAllowThreads();
41561 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41562
41563 wxPyEndAllowThreads(__tstate);
41564 if (PyErr_Occurred()) SWIG_fail;
41565 }
41566 {
41567 resultobj = wxPyMake_wxObject(result, 0);
41568 }
41569 return resultobj;
41570 fail:
41571 return NULL;
41572 }
41573
41574
41575 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41576 PyObject *resultobj;
41577 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41578 wxButton *result;
41579 PyObject * obj0 = 0 ;
41580 char *kwnames[] = {
41581 (char *) "self", NULL
41582 };
41583
41584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41586 if (SWIG_arg_fail(1)) SWIG_fail;
41587 {
41588 PyThreadState* __tstate = wxPyBeginAllowThreads();
41589 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41590
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 {
41595 resultobj = wxPyMake_wxObject(result, 0);
41596 }
41597 return resultobj;
41598 fail:
41599 return NULL;
41600 }
41601
41602
41603 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41604 PyObject *resultobj;
41605 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41606 wxButton *result;
41607 PyObject * obj0 = 0 ;
41608 char *kwnames[] = {
41609 (char *) "self", NULL
41610 };
41611
41612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41614 if (SWIG_arg_fail(1)) SWIG_fail;
41615 {
41616 PyThreadState* __tstate = wxPyBeginAllowThreads();
41617 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41618
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 {
41623 resultobj = wxPyMake_wxObject(result, 0);
41624 }
41625 return resultobj;
41626 fail:
41627 return NULL;
41628 }
41629
41630
41631 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41632 PyObject *resultobj;
41633 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41634 wxButton *result;
41635 PyObject * obj0 = 0 ;
41636 char *kwnames[] = {
41637 (char *) "self", NULL
41638 };
41639
41640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41642 if (SWIG_arg_fail(1)) SWIG_fail;
41643 {
41644 PyThreadState* __tstate = wxPyBeginAllowThreads();
41645 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41646
41647 wxPyEndAllowThreads(__tstate);
41648 if (PyErr_Occurred()) SWIG_fail;
41649 }
41650 {
41651 resultobj = wxPyMake_wxObject(result, 0);
41652 }
41653 return resultobj;
41654 fail:
41655 return NULL;
41656 }
41657
41658
41659 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41660 PyObject *obj;
41661 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41662 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41663 Py_INCREF(obj);
41664 return Py_BuildValue((char *)"");
41665 }
41666 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41667 PyObject *resultobj;
41668 int arg1 = (int) 0 ;
41669 int arg2 = (int) 0 ;
41670 wxGBPosition *result;
41671 PyObject * obj0 = 0 ;
41672 PyObject * obj1 = 0 ;
41673 char *kwnames[] = {
41674 (char *) "row",(char *) "col", NULL
41675 };
41676
41677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41678 if (obj0) {
41679 {
41680 arg1 = (int)(SWIG_As_int(obj0));
41681 if (SWIG_arg_fail(1)) SWIG_fail;
41682 }
41683 }
41684 if (obj1) {
41685 {
41686 arg2 = (int)(SWIG_As_int(obj1));
41687 if (SWIG_arg_fail(2)) SWIG_fail;
41688 }
41689 }
41690 {
41691 PyThreadState* __tstate = wxPyBeginAllowThreads();
41692 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41693
41694 wxPyEndAllowThreads(__tstate);
41695 if (PyErr_Occurred()) SWIG_fail;
41696 }
41697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41698 return resultobj;
41699 fail:
41700 return NULL;
41701 }
41702
41703
41704 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41705 PyObject *resultobj;
41706 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41707 int result;
41708 PyObject * obj0 = 0 ;
41709 char *kwnames[] = {
41710 (char *) "self", NULL
41711 };
41712
41713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41715 if (SWIG_arg_fail(1)) SWIG_fail;
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 result = (int)((wxGBPosition const *)arg1)->GetRow();
41719
41720 wxPyEndAllowThreads(__tstate);
41721 if (PyErr_Occurred()) SWIG_fail;
41722 }
41723 {
41724 resultobj = SWIG_From_int((int)(result));
41725 }
41726 return resultobj;
41727 fail:
41728 return NULL;
41729 }
41730
41731
41732 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41733 PyObject *resultobj;
41734 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41735 int result;
41736 PyObject * obj0 = 0 ;
41737 char *kwnames[] = {
41738 (char *) "self", NULL
41739 };
41740
41741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41743 if (SWIG_arg_fail(1)) SWIG_fail;
41744 {
41745 PyThreadState* __tstate = wxPyBeginAllowThreads();
41746 result = (int)((wxGBPosition const *)arg1)->GetCol();
41747
41748 wxPyEndAllowThreads(__tstate);
41749 if (PyErr_Occurred()) SWIG_fail;
41750 }
41751 {
41752 resultobj = SWIG_From_int((int)(result));
41753 }
41754 return resultobj;
41755 fail:
41756 return NULL;
41757 }
41758
41759
41760 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41761 PyObject *resultobj;
41762 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41763 int arg2 ;
41764 PyObject * obj0 = 0 ;
41765 PyObject * obj1 = 0 ;
41766 char *kwnames[] = {
41767 (char *) "self",(char *) "row", NULL
41768 };
41769
41770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41772 if (SWIG_arg_fail(1)) SWIG_fail;
41773 {
41774 arg2 = (int)(SWIG_As_int(obj1));
41775 if (SWIG_arg_fail(2)) SWIG_fail;
41776 }
41777 {
41778 PyThreadState* __tstate = wxPyBeginAllowThreads();
41779 (arg1)->SetRow(arg2);
41780
41781 wxPyEndAllowThreads(__tstate);
41782 if (PyErr_Occurred()) SWIG_fail;
41783 }
41784 Py_INCREF(Py_None); resultobj = Py_None;
41785 return resultobj;
41786 fail:
41787 return NULL;
41788 }
41789
41790
41791 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41792 PyObject *resultobj;
41793 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41794 int arg2 ;
41795 PyObject * obj0 = 0 ;
41796 PyObject * obj1 = 0 ;
41797 char *kwnames[] = {
41798 (char *) "self",(char *) "col", NULL
41799 };
41800
41801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41803 if (SWIG_arg_fail(1)) SWIG_fail;
41804 {
41805 arg2 = (int)(SWIG_As_int(obj1));
41806 if (SWIG_arg_fail(2)) SWIG_fail;
41807 }
41808 {
41809 PyThreadState* __tstate = wxPyBeginAllowThreads();
41810 (arg1)->SetCol(arg2);
41811
41812 wxPyEndAllowThreads(__tstate);
41813 if (PyErr_Occurred()) SWIG_fail;
41814 }
41815 Py_INCREF(Py_None); resultobj = Py_None;
41816 return resultobj;
41817 fail:
41818 return NULL;
41819 }
41820
41821
41822 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41823 PyObject *resultobj;
41824 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41825 wxGBPosition *arg2 = 0 ;
41826 bool result;
41827 wxGBPosition temp2 ;
41828 PyObject * obj0 = 0 ;
41829 PyObject * obj1 = 0 ;
41830 char *kwnames[] = {
41831 (char *) "self",(char *) "other", NULL
41832 };
41833
41834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41836 if (SWIG_arg_fail(1)) SWIG_fail;
41837 {
41838 arg2 = &temp2;
41839 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41840 }
41841 {
41842 PyThreadState* __tstate = wxPyBeginAllowThreads();
41843 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41844
41845 wxPyEndAllowThreads(__tstate);
41846 if (PyErr_Occurred()) SWIG_fail;
41847 }
41848 {
41849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41850 }
41851 return resultobj;
41852 fail:
41853 return NULL;
41854 }
41855
41856
41857 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41858 PyObject *resultobj;
41859 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41860 wxGBPosition *arg2 = 0 ;
41861 bool result;
41862 wxGBPosition temp2 ;
41863 PyObject * obj0 = 0 ;
41864 PyObject * obj1 = 0 ;
41865 char *kwnames[] = {
41866 (char *) "self",(char *) "other", NULL
41867 };
41868
41869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41871 if (SWIG_arg_fail(1)) SWIG_fail;
41872 {
41873 arg2 = &temp2;
41874 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41875 }
41876 {
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41879
41880 wxPyEndAllowThreads(__tstate);
41881 if (PyErr_Occurred()) SWIG_fail;
41882 }
41883 {
41884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41885 }
41886 return resultobj;
41887 fail:
41888 return NULL;
41889 }
41890
41891
41892 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41893 PyObject *resultobj;
41894 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41895 int arg2 = (int) 0 ;
41896 int arg3 = (int) 0 ;
41897 PyObject * obj0 = 0 ;
41898 PyObject * obj1 = 0 ;
41899 PyObject * obj2 = 0 ;
41900 char *kwnames[] = {
41901 (char *) "self",(char *) "row",(char *) "col", NULL
41902 };
41903
41904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41906 if (SWIG_arg_fail(1)) SWIG_fail;
41907 if (obj1) {
41908 {
41909 arg2 = (int)(SWIG_As_int(obj1));
41910 if (SWIG_arg_fail(2)) SWIG_fail;
41911 }
41912 }
41913 if (obj2) {
41914 {
41915 arg3 = (int)(SWIG_As_int(obj2));
41916 if (SWIG_arg_fail(3)) SWIG_fail;
41917 }
41918 }
41919 {
41920 PyThreadState* __tstate = wxPyBeginAllowThreads();
41921 wxGBPosition_Set(arg1,arg2,arg3);
41922
41923 wxPyEndAllowThreads(__tstate);
41924 if (PyErr_Occurred()) SWIG_fail;
41925 }
41926 Py_INCREF(Py_None); resultobj = Py_None;
41927 return resultobj;
41928 fail:
41929 return NULL;
41930 }
41931
41932
41933 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41934 PyObject *resultobj;
41935 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41936 PyObject *result;
41937 PyObject * obj0 = 0 ;
41938 char *kwnames[] = {
41939 (char *) "self", NULL
41940 };
41941
41942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41944 if (SWIG_arg_fail(1)) SWIG_fail;
41945 {
41946 PyThreadState* __tstate = wxPyBeginAllowThreads();
41947 result = (PyObject *)wxGBPosition_Get(arg1);
41948
41949 wxPyEndAllowThreads(__tstate);
41950 if (PyErr_Occurred()) SWIG_fail;
41951 }
41952 resultobj = result;
41953 return resultobj;
41954 fail:
41955 return NULL;
41956 }
41957
41958
41959 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41960 PyObject *obj;
41961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41962 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41963 Py_INCREF(obj);
41964 return Py_BuildValue((char *)"");
41965 }
41966 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41967 PyObject *resultobj;
41968 int arg1 = (int) 1 ;
41969 int arg2 = (int) 1 ;
41970 wxGBSpan *result;
41971 PyObject * obj0 = 0 ;
41972 PyObject * obj1 = 0 ;
41973 char *kwnames[] = {
41974 (char *) "rowspan",(char *) "colspan", NULL
41975 };
41976
41977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41978 if (obj0) {
41979 {
41980 arg1 = (int)(SWIG_As_int(obj0));
41981 if (SWIG_arg_fail(1)) SWIG_fail;
41982 }
41983 }
41984 if (obj1) {
41985 {
41986 arg2 = (int)(SWIG_As_int(obj1));
41987 if (SWIG_arg_fail(2)) SWIG_fail;
41988 }
41989 }
41990 {
41991 PyThreadState* __tstate = wxPyBeginAllowThreads();
41992 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41993
41994 wxPyEndAllowThreads(__tstate);
41995 if (PyErr_Occurred()) SWIG_fail;
41996 }
41997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41998 return resultobj;
41999 fail:
42000 return NULL;
42001 }
42002
42003
42004 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42005 PyObject *resultobj;
42006 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42007 int result;
42008 PyObject * obj0 = 0 ;
42009 char *kwnames[] = {
42010 (char *) "self", NULL
42011 };
42012
42013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42015 if (SWIG_arg_fail(1)) SWIG_fail;
42016 {
42017 PyThreadState* __tstate = wxPyBeginAllowThreads();
42018 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42019
42020 wxPyEndAllowThreads(__tstate);
42021 if (PyErr_Occurred()) SWIG_fail;
42022 }
42023 {
42024 resultobj = SWIG_From_int((int)(result));
42025 }
42026 return resultobj;
42027 fail:
42028 return NULL;
42029 }
42030
42031
42032 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42033 PyObject *resultobj;
42034 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42035 int result;
42036 PyObject * obj0 = 0 ;
42037 char *kwnames[] = {
42038 (char *) "self", NULL
42039 };
42040
42041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42043 if (SWIG_arg_fail(1)) SWIG_fail;
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42047
42048 wxPyEndAllowThreads(__tstate);
42049 if (PyErr_Occurred()) SWIG_fail;
42050 }
42051 {
42052 resultobj = SWIG_From_int((int)(result));
42053 }
42054 return resultobj;
42055 fail:
42056 return NULL;
42057 }
42058
42059
42060 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42061 PyObject *resultobj;
42062 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42063 int arg2 ;
42064 PyObject * obj0 = 0 ;
42065 PyObject * obj1 = 0 ;
42066 char *kwnames[] = {
42067 (char *) "self",(char *) "rowspan", NULL
42068 };
42069
42070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42072 if (SWIG_arg_fail(1)) SWIG_fail;
42073 {
42074 arg2 = (int)(SWIG_As_int(obj1));
42075 if (SWIG_arg_fail(2)) SWIG_fail;
42076 }
42077 {
42078 PyThreadState* __tstate = wxPyBeginAllowThreads();
42079 (arg1)->SetRowspan(arg2);
42080
42081 wxPyEndAllowThreads(__tstate);
42082 if (PyErr_Occurred()) SWIG_fail;
42083 }
42084 Py_INCREF(Py_None); resultobj = Py_None;
42085 return resultobj;
42086 fail:
42087 return NULL;
42088 }
42089
42090
42091 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42092 PyObject *resultobj;
42093 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42094 int arg2 ;
42095 PyObject * obj0 = 0 ;
42096 PyObject * obj1 = 0 ;
42097 char *kwnames[] = {
42098 (char *) "self",(char *) "colspan", NULL
42099 };
42100
42101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42103 if (SWIG_arg_fail(1)) SWIG_fail;
42104 {
42105 arg2 = (int)(SWIG_As_int(obj1));
42106 if (SWIG_arg_fail(2)) SWIG_fail;
42107 }
42108 {
42109 PyThreadState* __tstate = wxPyBeginAllowThreads();
42110 (arg1)->SetColspan(arg2);
42111
42112 wxPyEndAllowThreads(__tstate);
42113 if (PyErr_Occurred()) SWIG_fail;
42114 }
42115 Py_INCREF(Py_None); resultobj = Py_None;
42116 return resultobj;
42117 fail:
42118 return NULL;
42119 }
42120
42121
42122 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42123 PyObject *resultobj;
42124 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42125 wxGBSpan *arg2 = 0 ;
42126 bool result;
42127 wxGBSpan temp2 ;
42128 PyObject * obj0 = 0 ;
42129 PyObject * obj1 = 0 ;
42130 char *kwnames[] = {
42131 (char *) "self",(char *) "other", NULL
42132 };
42133
42134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42136 if (SWIG_arg_fail(1)) SWIG_fail;
42137 {
42138 arg2 = &temp2;
42139 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42140 }
42141 {
42142 PyThreadState* __tstate = wxPyBeginAllowThreads();
42143 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42144
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 {
42149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42150 }
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42158 PyObject *resultobj;
42159 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42160 wxGBSpan *arg2 = 0 ;
42161 bool result;
42162 wxGBSpan temp2 ;
42163 PyObject * obj0 = 0 ;
42164 PyObject * obj1 = 0 ;
42165 char *kwnames[] = {
42166 (char *) "self",(char *) "other", NULL
42167 };
42168
42169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42171 if (SWIG_arg_fail(1)) SWIG_fail;
42172 {
42173 arg2 = &temp2;
42174 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42175 }
42176 {
42177 PyThreadState* __tstate = wxPyBeginAllowThreads();
42178 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
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_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42193 PyObject *resultobj;
42194 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42195 int arg2 = (int) 1 ;
42196 int arg3 = (int) 1 ;
42197 PyObject * obj0 = 0 ;
42198 PyObject * obj1 = 0 ;
42199 PyObject * obj2 = 0 ;
42200 char *kwnames[] = {
42201 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42202 };
42203
42204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42206 if (SWIG_arg_fail(1)) SWIG_fail;
42207 if (obj1) {
42208 {
42209 arg2 = (int)(SWIG_As_int(obj1));
42210 if (SWIG_arg_fail(2)) SWIG_fail;
42211 }
42212 }
42213 if (obj2) {
42214 {
42215 arg3 = (int)(SWIG_As_int(obj2));
42216 if (SWIG_arg_fail(3)) SWIG_fail;
42217 }
42218 }
42219 {
42220 PyThreadState* __tstate = wxPyBeginAllowThreads();
42221 wxGBSpan_Set(arg1,arg2,arg3);
42222
42223 wxPyEndAllowThreads(__tstate);
42224 if (PyErr_Occurred()) SWIG_fail;
42225 }
42226 Py_INCREF(Py_None); resultobj = Py_None;
42227 return resultobj;
42228 fail:
42229 return NULL;
42230 }
42231
42232
42233 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42234 PyObject *resultobj;
42235 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42236 PyObject *result;
42237 PyObject * obj0 = 0 ;
42238 char *kwnames[] = {
42239 (char *) "self", NULL
42240 };
42241
42242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42244 if (SWIG_arg_fail(1)) SWIG_fail;
42245 {
42246 PyThreadState* __tstate = wxPyBeginAllowThreads();
42247 result = (PyObject *)wxGBSpan_Get(arg1);
42248
42249 wxPyEndAllowThreads(__tstate);
42250 if (PyErr_Occurred()) SWIG_fail;
42251 }
42252 resultobj = result;
42253 return resultobj;
42254 fail:
42255 return NULL;
42256 }
42257
42258
42259 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42260 PyObject *obj;
42261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42262 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42263 Py_INCREF(obj);
42264 return Py_BuildValue((char *)"");
42265 }
42266 static int _wrap_DefaultSpan_set(PyObject *) {
42267 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42268 return 1;
42269 }
42270
42271
42272 static PyObject *_wrap_DefaultSpan_get(void) {
42273 PyObject *pyobj;
42274
42275 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42276 return pyobj;
42277 }
42278
42279
42280 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42281 PyObject *resultobj;
42282 wxGBSizerItem *result;
42283 char *kwnames[] = {
42284 NULL
42285 };
42286
42287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42288 {
42289 PyThreadState* __tstate = wxPyBeginAllowThreads();
42290 result = (wxGBSizerItem *)new wxGBSizerItem();
42291
42292 wxPyEndAllowThreads(__tstate);
42293 if (PyErr_Occurred()) SWIG_fail;
42294 }
42295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42296 return resultobj;
42297 fail:
42298 return NULL;
42299 }
42300
42301
42302 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42303 PyObject *resultobj;
42304 wxWindow *arg1 = (wxWindow *) 0 ;
42305 wxGBPosition *arg2 = 0 ;
42306 wxGBSpan *arg3 = 0 ;
42307 int arg4 ;
42308 int arg5 ;
42309 PyObject *arg6 = (PyObject *) NULL ;
42310 wxGBSizerItem *result;
42311 wxGBPosition temp2 ;
42312 wxGBSpan temp3 ;
42313 PyObject * obj0 = 0 ;
42314 PyObject * obj1 = 0 ;
42315 PyObject * obj2 = 0 ;
42316 PyObject * obj3 = 0 ;
42317 PyObject * obj4 = 0 ;
42318 PyObject * obj5 = 0 ;
42319 char *kwnames[] = {
42320 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42321 };
42322
42323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42325 if (SWIG_arg_fail(1)) SWIG_fail;
42326 {
42327 arg2 = &temp2;
42328 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42329 }
42330 {
42331 arg3 = &temp3;
42332 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42333 }
42334 {
42335 arg4 = (int)(SWIG_As_int(obj3));
42336 if (SWIG_arg_fail(4)) SWIG_fail;
42337 }
42338 {
42339 arg5 = (int)(SWIG_As_int(obj4));
42340 if (SWIG_arg_fail(5)) SWIG_fail;
42341 }
42342 if (obj5) {
42343 arg6 = obj5;
42344 }
42345 {
42346 PyThreadState* __tstate = wxPyBeginAllowThreads();
42347 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42348
42349 wxPyEndAllowThreads(__tstate);
42350 if (PyErr_Occurred()) SWIG_fail;
42351 }
42352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42353 return resultobj;
42354 fail:
42355 return NULL;
42356 }
42357
42358
42359 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42360 PyObject *resultobj;
42361 wxSizer *arg1 = (wxSizer *) 0 ;
42362 wxGBPosition *arg2 = 0 ;
42363 wxGBSpan *arg3 = 0 ;
42364 int arg4 ;
42365 int arg5 ;
42366 PyObject *arg6 = (PyObject *) NULL ;
42367 wxGBSizerItem *result;
42368 wxGBPosition temp2 ;
42369 wxGBSpan temp3 ;
42370 PyObject * obj0 = 0 ;
42371 PyObject * obj1 = 0 ;
42372 PyObject * obj2 = 0 ;
42373 PyObject * obj3 = 0 ;
42374 PyObject * obj4 = 0 ;
42375 PyObject * obj5 = 0 ;
42376 char *kwnames[] = {
42377 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42378 };
42379
42380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42382 if (SWIG_arg_fail(1)) SWIG_fail;
42383 {
42384 arg2 = &temp2;
42385 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42386 }
42387 {
42388 arg3 = &temp3;
42389 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42390 }
42391 {
42392 arg4 = (int)(SWIG_As_int(obj3));
42393 if (SWIG_arg_fail(4)) SWIG_fail;
42394 }
42395 {
42396 arg5 = (int)(SWIG_As_int(obj4));
42397 if (SWIG_arg_fail(5)) SWIG_fail;
42398 }
42399 if (obj5) {
42400 arg6 = obj5;
42401 }
42402 {
42403 PyThreadState* __tstate = wxPyBeginAllowThreads();
42404 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42405
42406 wxPyEndAllowThreads(__tstate);
42407 if (PyErr_Occurred()) SWIG_fail;
42408 }
42409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42410 return resultobj;
42411 fail:
42412 return NULL;
42413 }
42414
42415
42416 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42417 PyObject *resultobj;
42418 int arg1 ;
42419 int arg2 ;
42420 wxGBPosition *arg3 = 0 ;
42421 wxGBSpan *arg4 = 0 ;
42422 int arg5 ;
42423 int arg6 ;
42424 PyObject *arg7 = (PyObject *) NULL ;
42425 wxGBSizerItem *result;
42426 wxGBPosition temp3 ;
42427 wxGBSpan temp4 ;
42428 PyObject * obj0 = 0 ;
42429 PyObject * obj1 = 0 ;
42430 PyObject * obj2 = 0 ;
42431 PyObject * obj3 = 0 ;
42432 PyObject * obj4 = 0 ;
42433 PyObject * obj5 = 0 ;
42434 PyObject * obj6 = 0 ;
42435 char *kwnames[] = {
42436 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42437 };
42438
42439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42440 {
42441 arg1 = (int)(SWIG_As_int(obj0));
42442 if (SWIG_arg_fail(1)) SWIG_fail;
42443 }
42444 {
42445 arg2 = (int)(SWIG_As_int(obj1));
42446 if (SWIG_arg_fail(2)) SWIG_fail;
42447 }
42448 {
42449 arg3 = &temp3;
42450 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42451 }
42452 {
42453 arg4 = &temp4;
42454 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42455 }
42456 {
42457 arg5 = (int)(SWIG_As_int(obj4));
42458 if (SWIG_arg_fail(5)) SWIG_fail;
42459 }
42460 {
42461 arg6 = (int)(SWIG_As_int(obj5));
42462 if (SWIG_arg_fail(6)) SWIG_fail;
42463 }
42464 if (obj6) {
42465 arg7 = obj6;
42466 }
42467 {
42468 PyThreadState* __tstate = wxPyBeginAllowThreads();
42469 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42470
42471 wxPyEndAllowThreads(__tstate);
42472 if (PyErr_Occurred()) SWIG_fail;
42473 }
42474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42475 return resultobj;
42476 fail:
42477 return NULL;
42478 }
42479
42480
42481 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42482 PyObject *resultobj;
42483 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42484 wxGBPosition result;
42485 PyObject * obj0 = 0 ;
42486 char *kwnames[] = {
42487 (char *) "self", NULL
42488 };
42489
42490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42492 if (SWIG_arg_fail(1)) SWIG_fail;
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 result = ((wxGBSizerItem const *)arg1)->GetPos();
42496
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 {
42501 wxGBPosition * resultptr;
42502 resultptr = new wxGBPosition((wxGBPosition &)(result));
42503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42504 }
42505 return resultobj;
42506 fail:
42507 return NULL;
42508 }
42509
42510
42511 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42512 PyObject *resultobj;
42513 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42514 wxGBSpan result;
42515 PyObject * obj0 = 0 ;
42516 char *kwnames[] = {
42517 (char *) "self", NULL
42518 };
42519
42520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42522 if (SWIG_arg_fail(1)) SWIG_fail;
42523 {
42524 PyThreadState* __tstate = wxPyBeginAllowThreads();
42525 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42526
42527 wxPyEndAllowThreads(__tstate);
42528 if (PyErr_Occurred()) SWIG_fail;
42529 }
42530 {
42531 wxGBSpan * resultptr;
42532 resultptr = new wxGBSpan((wxGBSpan &)(result));
42533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42534 }
42535 return resultobj;
42536 fail:
42537 return NULL;
42538 }
42539
42540
42541 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42542 PyObject *resultobj;
42543 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42544 wxGBPosition *arg2 = 0 ;
42545 bool result;
42546 wxGBPosition temp2 ;
42547 PyObject * obj0 = 0 ;
42548 PyObject * obj1 = 0 ;
42549 char *kwnames[] = {
42550 (char *) "self",(char *) "pos", NULL
42551 };
42552
42553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42555 if (SWIG_arg_fail(1)) SWIG_fail;
42556 {
42557 arg2 = &temp2;
42558 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42559 }
42560 {
42561 PyThreadState* __tstate = wxPyBeginAllowThreads();
42562 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42563
42564 wxPyEndAllowThreads(__tstate);
42565 if (PyErr_Occurred()) SWIG_fail;
42566 }
42567 {
42568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42569 }
42570 return resultobj;
42571 fail:
42572 return NULL;
42573 }
42574
42575
42576 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42577 PyObject *resultobj;
42578 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42579 wxGBSpan *arg2 = 0 ;
42580 bool result;
42581 wxGBSpan temp2 ;
42582 PyObject * obj0 = 0 ;
42583 PyObject * obj1 = 0 ;
42584 char *kwnames[] = {
42585 (char *) "self",(char *) "span", NULL
42586 };
42587
42588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42590 if (SWIG_arg_fail(1)) SWIG_fail;
42591 {
42592 arg2 = &temp2;
42593 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42594 }
42595 {
42596 PyThreadState* __tstate = wxPyBeginAllowThreads();
42597 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42598
42599 wxPyEndAllowThreads(__tstate);
42600 if (PyErr_Occurred()) SWIG_fail;
42601 }
42602 {
42603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42604 }
42605 return resultobj;
42606 fail:
42607 return NULL;
42608 }
42609
42610
42611 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42612 PyObject *resultobj;
42613 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42614 wxGBSizerItem *arg2 = 0 ;
42615 bool result;
42616 PyObject * obj0 = 0 ;
42617 PyObject * obj1 = 0 ;
42618 char *kwnames[] = {
42619 (char *) "self",(char *) "other", NULL
42620 };
42621
42622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42624 if (SWIG_arg_fail(1)) SWIG_fail;
42625 {
42626 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42627 if (SWIG_arg_fail(2)) SWIG_fail;
42628 if (arg2 == NULL) {
42629 SWIG_null_ref("wxGBSizerItem");
42630 }
42631 if (SWIG_arg_fail(2)) SWIG_fail;
42632 }
42633 {
42634 PyThreadState* __tstate = wxPyBeginAllowThreads();
42635 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42636
42637 wxPyEndAllowThreads(__tstate);
42638 if (PyErr_Occurred()) SWIG_fail;
42639 }
42640 {
42641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42642 }
42643 return resultobj;
42644 fail:
42645 return NULL;
42646 }
42647
42648
42649 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42650 PyObject *resultobj;
42651 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42652 wxGBPosition *arg2 = 0 ;
42653 wxGBSpan *arg3 = 0 ;
42654 bool result;
42655 wxGBPosition temp2 ;
42656 wxGBSpan temp3 ;
42657 PyObject * obj0 = 0 ;
42658 PyObject * obj1 = 0 ;
42659 PyObject * obj2 = 0 ;
42660 char *kwnames[] = {
42661 (char *) "self",(char *) "pos",(char *) "span", NULL
42662 };
42663
42664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42666 if (SWIG_arg_fail(1)) SWIG_fail;
42667 {
42668 arg2 = &temp2;
42669 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42670 }
42671 {
42672 arg3 = &temp3;
42673 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42674 }
42675 {
42676 PyThreadState* __tstate = wxPyBeginAllowThreads();
42677 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42678
42679 wxPyEndAllowThreads(__tstate);
42680 if (PyErr_Occurred()) SWIG_fail;
42681 }
42682 {
42683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42684 }
42685 return resultobj;
42686 fail:
42687 return NULL;
42688 }
42689
42690
42691 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42692 PyObject *resultobj;
42693 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42694 wxGBPosition result;
42695 PyObject * obj0 = 0 ;
42696 char *kwnames[] = {
42697 (char *) "self", NULL
42698 };
42699
42700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42702 if (SWIG_arg_fail(1)) SWIG_fail;
42703 {
42704 PyThreadState* __tstate = wxPyBeginAllowThreads();
42705 result = wxGBSizerItem_GetEndPos(arg1);
42706
42707 wxPyEndAllowThreads(__tstate);
42708 if (PyErr_Occurred()) SWIG_fail;
42709 }
42710 {
42711 wxGBPosition * resultptr;
42712 resultptr = new wxGBPosition((wxGBPosition &)(result));
42713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42714 }
42715 return resultobj;
42716 fail:
42717 return NULL;
42718 }
42719
42720
42721 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42722 PyObject *resultobj;
42723 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42724 wxGridBagSizer *result;
42725 PyObject * obj0 = 0 ;
42726 char *kwnames[] = {
42727 (char *) "self", NULL
42728 };
42729
42730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42732 if (SWIG_arg_fail(1)) SWIG_fail;
42733 {
42734 PyThreadState* __tstate = wxPyBeginAllowThreads();
42735 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42736
42737 wxPyEndAllowThreads(__tstate);
42738 if (PyErr_Occurred()) SWIG_fail;
42739 }
42740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42741 return resultobj;
42742 fail:
42743 return NULL;
42744 }
42745
42746
42747 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42748 PyObject *resultobj;
42749 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42750 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42751 PyObject * obj0 = 0 ;
42752 PyObject * obj1 = 0 ;
42753 char *kwnames[] = {
42754 (char *) "self",(char *) "sizer", NULL
42755 };
42756
42757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42759 if (SWIG_arg_fail(1)) SWIG_fail;
42760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42761 if (SWIG_arg_fail(2)) SWIG_fail;
42762 {
42763 PyThreadState* __tstate = wxPyBeginAllowThreads();
42764 (arg1)->SetGBSizer(arg2);
42765
42766 wxPyEndAllowThreads(__tstate);
42767 if (PyErr_Occurred()) SWIG_fail;
42768 }
42769 Py_INCREF(Py_None); resultobj = Py_None;
42770 return resultobj;
42771 fail:
42772 return NULL;
42773 }
42774
42775
42776 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42777 PyObject *obj;
42778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42779 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42780 Py_INCREF(obj);
42781 return Py_BuildValue((char *)"");
42782 }
42783 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42784 PyObject *resultobj;
42785 int arg1 = (int) 0 ;
42786 int arg2 = (int) 0 ;
42787 wxGridBagSizer *result;
42788 PyObject * obj0 = 0 ;
42789 PyObject * obj1 = 0 ;
42790 char *kwnames[] = {
42791 (char *) "vgap",(char *) "hgap", NULL
42792 };
42793
42794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42795 if (obj0) {
42796 {
42797 arg1 = (int)(SWIG_As_int(obj0));
42798 if (SWIG_arg_fail(1)) SWIG_fail;
42799 }
42800 }
42801 if (obj1) {
42802 {
42803 arg2 = (int)(SWIG_As_int(obj1));
42804 if (SWIG_arg_fail(2)) SWIG_fail;
42805 }
42806 }
42807 {
42808 PyThreadState* __tstate = wxPyBeginAllowThreads();
42809 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42810
42811 wxPyEndAllowThreads(__tstate);
42812 if (PyErr_Occurred()) SWIG_fail;
42813 }
42814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42815 return resultobj;
42816 fail:
42817 return NULL;
42818 }
42819
42820
42821 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42822 PyObject *resultobj;
42823 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42824 PyObject *arg2 = (PyObject *) 0 ;
42825 wxGBPosition *arg3 = 0 ;
42826 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42827 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42828 int arg5 = (int) 0 ;
42829 int arg6 = (int) 0 ;
42830 PyObject *arg7 = (PyObject *) NULL ;
42831 wxGBSizerItem *result;
42832 wxGBPosition temp3 ;
42833 wxGBSpan temp4 ;
42834 PyObject * obj0 = 0 ;
42835 PyObject * obj1 = 0 ;
42836 PyObject * obj2 = 0 ;
42837 PyObject * obj3 = 0 ;
42838 PyObject * obj4 = 0 ;
42839 PyObject * obj5 = 0 ;
42840 PyObject * obj6 = 0 ;
42841 char *kwnames[] = {
42842 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42843 };
42844
42845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42847 if (SWIG_arg_fail(1)) SWIG_fail;
42848 arg2 = obj1;
42849 {
42850 arg3 = &temp3;
42851 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42852 }
42853 if (obj3) {
42854 {
42855 arg4 = &temp4;
42856 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42857 }
42858 }
42859 if (obj4) {
42860 {
42861 arg5 = (int)(SWIG_As_int(obj4));
42862 if (SWIG_arg_fail(5)) SWIG_fail;
42863 }
42864 }
42865 if (obj5) {
42866 {
42867 arg6 = (int)(SWIG_As_int(obj5));
42868 if (SWIG_arg_fail(6)) SWIG_fail;
42869 }
42870 }
42871 if (obj6) {
42872 arg7 = obj6;
42873 }
42874 {
42875 PyThreadState* __tstate = wxPyBeginAllowThreads();
42876 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42877
42878 wxPyEndAllowThreads(__tstate);
42879 if (PyErr_Occurred()) SWIG_fail;
42880 }
42881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42882 return resultobj;
42883 fail:
42884 return NULL;
42885 }
42886
42887
42888 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42889 PyObject *resultobj;
42890 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42891 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42892 wxGBSizerItem *result;
42893 PyObject * obj0 = 0 ;
42894 PyObject * obj1 = 0 ;
42895 char *kwnames[] = {
42896 (char *) "self",(char *) "item", NULL
42897 };
42898
42899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42901 if (SWIG_arg_fail(1)) SWIG_fail;
42902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42903 if (SWIG_arg_fail(2)) SWIG_fail;
42904 {
42905 PyThreadState* __tstate = wxPyBeginAllowThreads();
42906 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42907
42908 wxPyEndAllowThreads(__tstate);
42909 if (PyErr_Occurred()) SWIG_fail;
42910 }
42911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42912 return resultobj;
42913 fail:
42914 return NULL;
42915 }
42916
42917
42918 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42919 PyObject *resultobj;
42920 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42921 int arg2 ;
42922 int arg3 ;
42923 wxSize result;
42924 PyObject * obj0 = 0 ;
42925 PyObject * obj1 = 0 ;
42926 PyObject * obj2 = 0 ;
42927 char *kwnames[] = {
42928 (char *) "self",(char *) "row",(char *) "col", NULL
42929 };
42930
42931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42933 if (SWIG_arg_fail(1)) SWIG_fail;
42934 {
42935 arg2 = (int)(SWIG_As_int(obj1));
42936 if (SWIG_arg_fail(2)) SWIG_fail;
42937 }
42938 {
42939 arg3 = (int)(SWIG_As_int(obj2));
42940 if (SWIG_arg_fail(3)) SWIG_fail;
42941 }
42942 {
42943 PyThreadState* __tstate = wxPyBeginAllowThreads();
42944 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42945
42946 wxPyEndAllowThreads(__tstate);
42947 if (PyErr_Occurred()) SWIG_fail;
42948 }
42949 {
42950 wxSize * resultptr;
42951 resultptr = new wxSize((wxSize &)(result));
42952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42953 }
42954 return resultobj;
42955 fail:
42956 return NULL;
42957 }
42958
42959
42960 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42961 PyObject *resultobj;
42962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42963 wxSize result;
42964 PyObject * obj0 = 0 ;
42965 char *kwnames[] = {
42966 (char *) "self", NULL
42967 };
42968
42969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42971 if (SWIG_arg_fail(1)) SWIG_fail;
42972 {
42973 PyThreadState* __tstate = wxPyBeginAllowThreads();
42974 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42975
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 {
42980 wxSize * resultptr;
42981 resultptr = new wxSize((wxSize &)(result));
42982 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42983 }
42984 return resultobj;
42985 fail:
42986 return NULL;
42987 }
42988
42989
42990 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42991 PyObject *resultobj;
42992 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42993 wxSize *arg2 = 0 ;
42994 wxSize temp2 ;
42995 PyObject * obj0 = 0 ;
42996 PyObject * obj1 = 0 ;
42997 char *kwnames[] = {
42998 (char *) "self",(char *) "sz", NULL
42999 };
43000
43001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43003 if (SWIG_arg_fail(1)) SWIG_fail;
43004 {
43005 arg2 = &temp2;
43006 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43007 }
43008 {
43009 PyThreadState* __tstate = wxPyBeginAllowThreads();
43010 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43011
43012 wxPyEndAllowThreads(__tstate);
43013 if (PyErr_Occurred()) SWIG_fail;
43014 }
43015 Py_INCREF(Py_None); resultobj = Py_None;
43016 return resultobj;
43017 fail:
43018 return NULL;
43019 }
43020
43021
43022 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43023 PyObject *resultobj;
43024 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43025 wxWindow *arg2 = (wxWindow *) 0 ;
43026 wxGBPosition result;
43027 PyObject * obj0 = 0 ;
43028 PyObject * obj1 = 0 ;
43029
43030 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43032 if (SWIG_arg_fail(1)) SWIG_fail;
43033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43034 if (SWIG_arg_fail(2)) SWIG_fail;
43035 {
43036 PyThreadState* __tstate = wxPyBeginAllowThreads();
43037 result = (arg1)->GetItemPosition(arg2);
43038
43039 wxPyEndAllowThreads(__tstate);
43040 if (PyErr_Occurred()) SWIG_fail;
43041 }
43042 {
43043 wxGBPosition * resultptr;
43044 resultptr = new wxGBPosition((wxGBPosition &)(result));
43045 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43046 }
43047 return resultobj;
43048 fail:
43049 return NULL;
43050 }
43051
43052
43053 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43054 PyObject *resultobj;
43055 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43056 wxSizer *arg2 = (wxSizer *) 0 ;
43057 wxGBPosition result;
43058 PyObject * obj0 = 0 ;
43059 PyObject * obj1 = 0 ;
43060
43061 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43063 if (SWIG_arg_fail(1)) SWIG_fail;
43064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43065 if (SWIG_arg_fail(2)) SWIG_fail;
43066 {
43067 PyThreadState* __tstate = wxPyBeginAllowThreads();
43068 result = (arg1)->GetItemPosition(arg2);
43069
43070 wxPyEndAllowThreads(__tstate);
43071 if (PyErr_Occurred()) SWIG_fail;
43072 }
43073 {
43074 wxGBPosition * resultptr;
43075 resultptr = new wxGBPosition((wxGBPosition &)(result));
43076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43077 }
43078 return resultobj;
43079 fail:
43080 return NULL;
43081 }
43082
43083
43084 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43085 PyObject *resultobj;
43086 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43087 size_t arg2 ;
43088 wxGBPosition result;
43089 PyObject * obj0 = 0 ;
43090 PyObject * obj1 = 0 ;
43091
43092 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43094 if (SWIG_arg_fail(1)) SWIG_fail;
43095 {
43096 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43097 if (SWIG_arg_fail(2)) SWIG_fail;
43098 }
43099 {
43100 PyThreadState* __tstate = wxPyBeginAllowThreads();
43101 result = (arg1)->GetItemPosition(arg2);
43102
43103 wxPyEndAllowThreads(__tstate);
43104 if (PyErr_Occurred()) SWIG_fail;
43105 }
43106 {
43107 wxGBPosition * resultptr;
43108 resultptr = new wxGBPosition((wxGBPosition &)(result));
43109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43110 }
43111 return resultobj;
43112 fail:
43113 return NULL;
43114 }
43115
43116
43117 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43118 int argc;
43119 PyObject *argv[3];
43120 int ii;
43121
43122 argc = PyObject_Length(args);
43123 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43124 argv[ii] = PyTuple_GetItem(args,ii);
43125 }
43126 if (argc == 2) {
43127 int _v;
43128 {
43129 void *ptr;
43130 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43131 _v = 0;
43132 PyErr_Clear();
43133 } else {
43134 _v = 1;
43135 }
43136 }
43137 if (_v) {
43138 {
43139 void *ptr;
43140 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43141 _v = 0;
43142 PyErr_Clear();
43143 } else {
43144 _v = 1;
43145 }
43146 }
43147 if (_v) {
43148 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43149 }
43150 }
43151 }
43152 if (argc == 2) {
43153 int _v;
43154 {
43155 void *ptr;
43156 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43157 _v = 0;
43158 PyErr_Clear();
43159 } else {
43160 _v = 1;
43161 }
43162 }
43163 if (_v) {
43164 {
43165 void *ptr;
43166 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43167 _v = 0;
43168 PyErr_Clear();
43169 } else {
43170 _v = 1;
43171 }
43172 }
43173 if (_v) {
43174 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43175 }
43176 }
43177 }
43178 if (argc == 2) {
43179 int _v;
43180 {
43181 void *ptr;
43182 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43183 _v = 0;
43184 PyErr_Clear();
43185 } else {
43186 _v = 1;
43187 }
43188 }
43189 if (_v) {
43190 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43191 if (_v) {
43192 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43193 }
43194 }
43195 }
43196
43197 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43198 return NULL;
43199 }
43200
43201
43202 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43203 PyObject *resultobj;
43204 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43205 wxWindow *arg2 = (wxWindow *) 0 ;
43206 wxGBPosition *arg3 = 0 ;
43207 bool result;
43208 wxGBPosition temp3 ;
43209 PyObject * obj0 = 0 ;
43210 PyObject * obj1 = 0 ;
43211 PyObject * obj2 = 0 ;
43212
43213 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43215 if (SWIG_arg_fail(1)) SWIG_fail;
43216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43217 if (SWIG_arg_fail(2)) SWIG_fail;
43218 {
43219 arg3 = &temp3;
43220 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43221 }
43222 {
43223 PyThreadState* __tstate = wxPyBeginAllowThreads();
43224 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43225
43226 wxPyEndAllowThreads(__tstate);
43227 if (PyErr_Occurred()) SWIG_fail;
43228 }
43229 {
43230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43231 }
43232 return resultobj;
43233 fail:
43234 return NULL;
43235 }
43236
43237
43238 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43239 PyObject *resultobj;
43240 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43241 wxSizer *arg2 = (wxSizer *) 0 ;
43242 wxGBPosition *arg3 = 0 ;
43243 bool result;
43244 wxGBPosition temp3 ;
43245 PyObject * obj0 = 0 ;
43246 PyObject * obj1 = 0 ;
43247 PyObject * obj2 = 0 ;
43248
43249 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43251 if (SWIG_arg_fail(1)) SWIG_fail;
43252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43253 if (SWIG_arg_fail(2)) SWIG_fail;
43254 {
43255 arg3 = &temp3;
43256 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43257 }
43258 {
43259 PyThreadState* __tstate = wxPyBeginAllowThreads();
43260 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43261
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 {
43266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43267 }
43268 return resultobj;
43269 fail:
43270 return NULL;
43271 }
43272
43273
43274 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43275 PyObject *resultobj;
43276 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43277 size_t arg2 ;
43278 wxGBPosition *arg3 = 0 ;
43279 bool result;
43280 wxGBPosition temp3 ;
43281 PyObject * obj0 = 0 ;
43282 PyObject * obj1 = 0 ;
43283 PyObject * obj2 = 0 ;
43284
43285 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43287 if (SWIG_arg_fail(1)) SWIG_fail;
43288 {
43289 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43290 if (SWIG_arg_fail(2)) SWIG_fail;
43291 }
43292 {
43293 arg3 = &temp3;
43294 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43295 }
43296 {
43297 PyThreadState* __tstate = wxPyBeginAllowThreads();
43298 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43299
43300 wxPyEndAllowThreads(__tstate);
43301 if (PyErr_Occurred()) SWIG_fail;
43302 }
43303 {
43304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43305 }
43306 return resultobj;
43307 fail:
43308 return NULL;
43309 }
43310
43311
43312 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43313 int argc;
43314 PyObject *argv[4];
43315 int ii;
43316
43317 argc = PyObject_Length(args);
43318 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43319 argv[ii] = PyTuple_GetItem(args,ii);
43320 }
43321 if (argc == 3) {
43322 int _v;
43323 {
43324 void *ptr;
43325 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43326 _v = 0;
43327 PyErr_Clear();
43328 } else {
43329 _v = 1;
43330 }
43331 }
43332 if (_v) {
43333 {
43334 void *ptr;
43335 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43336 _v = 0;
43337 PyErr_Clear();
43338 } else {
43339 _v = 1;
43340 }
43341 }
43342 if (_v) {
43343 {
43344 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43345 }
43346 if (_v) {
43347 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43348 }
43349 }
43350 }
43351 }
43352 if (argc == 3) {
43353 int _v;
43354 {
43355 void *ptr;
43356 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43357 _v = 0;
43358 PyErr_Clear();
43359 } else {
43360 _v = 1;
43361 }
43362 }
43363 if (_v) {
43364 {
43365 void *ptr;
43366 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43367 _v = 0;
43368 PyErr_Clear();
43369 } else {
43370 _v = 1;
43371 }
43372 }
43373 if (_v) {
43374 {
43375 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43376 }
43377 if (_v) {
43378 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43379 }
43380 }
43381 }
43382 }
43383 if (argc == 3) {
43384 int _v;
43385 {
43386 void *ptr;
43387 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43388 _v = 0;
43389 PyErr_Clear();
43390 } else {
43391 _v = 1;
43392 }
43393 }
43394 if (_v) {
43395 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43396 if (_v) {
43397 {
43398 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43399 }
43400 if (_v) {
43401 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43402 }
43403 }
43404 }
43405 }
43406
43407 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43408 return NULL;
43409 }
43410
43411
43412 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43413 PyObject *resultobj;
43414 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43415 wxWindow *arg2 = (wxWindow *) 0 ;
43416 wxGBSpan result;
43417 PyObject * obj0 = 0 ;
43418 PyObject * obj1 = 0 ;
43419
43420 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43422 if (SWIG_arg_fail(1)) SWIG_fail;
43423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43424 if (SWIG_arg_fail(2)) SWIG_fail;
43425 {
43426 PyThreadState* __tstate = wxPyBeginAllowThreads();
43427 result = (arg1)->GetItemSpan(arg2);
43428
43429 wxPyEndAllowThreads(__tstate);
43430 if (PyErr_Occurred()) SWIG_fail;
43431 }
43432 {
43433 wxGBSpan * resultptr;
43434 resultptr = new wxGBSpan((wxGBSpan &)(result));
43435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43436 }
43437 return resultobj;
43438 fail:
43439 return NULL;
43440 }
43441
43442
43443 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43444 PyObject *resultobj;
43445 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43446 wxSizer *arg2 = (wxSizer *) 0 ;
43447 wxGBSpan result;
43448 PyObject * obj0 = 0 ;
43449 PyObject * obj1 = 0 ;
43450
43451 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43453 if (SWIG_arg_fail(1)) SWIG_fail;
43454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43455 if (SWIG_arg_fail(2)) SWIG_fail;
43456 {
43457 PyThreadState* __tstate = wxPyBeginAllowThreads();
43458 result = (arg1)->GetItemSpan(arg2);
43459
43460 wxPyEndAllowThreads(__tstate);
43461 if (PyErr_Occurred()) SWIG_fail;
43462 }
43463 {
43464 wxGBSpan * resultptr;
43465 resultptr = new wxGBSpan((wxGBSpan &)(result));
43466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43467 }
43468 return resultobj;
43469 fail:
43470 return NULL;
43471 }
43472
43473
43474 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43475 PyObject *resultobj;
43476 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43477 size_t arg2 ;
43478 wxGBSpan result;
43479 PyObject * obj0 = 0 ;
43480 PyObject * obj1 = 0 ;
43481
43482 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43484 if (SWIG_arg_fail(1)) SWIG_fail;
43485 {
43486 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43487 if (SWIG_arg_fail(2)) SWIG_fail;
43488 }
43489 {
43490 PyThreadState* __tstate = wxPyBeginAllowThreads();
43491 result = (arg1)->GetItemSpan(arg2);
43492
43493 wxPyEndAllowThreads(__tstate);
43494 if (PyErr_Occurred()) SWIG_fail;
43495 }
43496 {
43497 wxGBSpan * resultptr;
43498 resultptr = new wxGBSpan((wxGBSpan &)(result));
43499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43500 }
43501 return resultobj;
43502 fail:
43503 return NULL;
43504 }
43505
43506
43507 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43508 int argc;
43509 PyObject *argv[3];
43510 int ii;
43511
43512 argc = PyObject_Length(args);
43513 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43514 argv[ii] = PyTuple_GetItem(args,ii);
43515 }
43516 if (argc == 2) {
43517 int _v;
43518 {
43519 void *ptr;
43520 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43521 _v = 0;
43522 PyErr_Clear();
43523 } else {
43524 _v = 1;
43525 }
43526 }
43527 if (_v) {
43528 {
43529 void *ptr;
43530 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43531 _v = 0;
43532 PyErr_Clear();
43533 } else {
43534 _v = 1;
43535 }
43536 }
43537 if (_v) {
43538 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43539 }
43540 }
43541 }
43542 if (argc == 2) {
43543 int _v;
43544 {
43545 void *ptr;
43546 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43547 _v = 0;
43548 PyErr_Clear();
43549 } else {
43550 _v = 1;
43551 }
43552 }
43553 if (_v) {
43554 {
43555 void *ptr;
43556 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43557 _v = 0;
43558 PyErr_Clear();
43559 } else {
43560 _v = 1;
43561 }
43562 }
43563 if (_v) {
43564 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43565 }
43566 }
43567 }
43568 if (argc == 2) {
43569 int _v;
43570 {
43571 void *ptr;
43572 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43573 _v = 0;
43574 PyErr_Clear();
43575 } else {
43576 _v = 1;
43577 }
43578 }
43579 if (_v) {
43580 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43581 if (_v) {
43582 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43583 }
43584 }
43585 }
43586
43587 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43588 return NULL;
43589 }
43590
43591
43592 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43593 PyObject *resultobj;
43594 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43595 wxWindow *arg2 = (wxWindow *) 0 ;
43596 wxGBSpan *arg3 = 0 ;
43597 bool result;
43598 wxGBSpan temp3 ;
43599 PyObject * obj0 = 0 ;
43600 PyObject * obj1 = 0 ;
43601 PyObject * obj2 = 0 ;
43602
43603 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43605 if (SWIG_arg_fail(1)) SWIG_fail;
43606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43607 if (SWIG_arg_fail(2)) SWIG_fail;
43608 {
43609 arg3 = &temp3;
43610 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43611 }
43612 {
43613 PyThreadState* __tstate = wxPyBeginAllowThreads();
43614 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43615
43616 wxPyEndAllowThreads(__tstate);
43617 if (PyErr_Occurred()) SWIG_fail;
43618 }
43619 {
43620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43621 }
43622 return resultobj;
43623 fail:
43624 return NULL;
43625 }
43626
43627
43628 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43629 PyObject *resultobj;
43630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43631 wxSizer *arg2 = (wxSizer *) 0 ;
43632 wxGBSpan *arg3 = 0 ;
43633 bool result;
43634 wxGBSpan temp3 ;
43635 PyObject * obj0 = 0 ;
43636 PyObject * obj1 = 0 ;
43637 PyObject * obj2 = 0 ;
43638
43639 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43641 if (SWIG_arg_fail(1)) SWIG_fail;
43642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43643 if (SWIG_arg_fail(2)) SWIG_fail;
43644 {
43645 arg3 = &temp3;
43646 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43647 }
43648 {
43649 PyThreadState* __tstate = wxPyBeginAllowThreads();
43650 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43651
43652 wxPyEndAllowThreads(__tstate);
43653 if (PyErr_Occurred()) SWIG_fail;
43654 }
43655 {
43656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43657 }
43658 return resultobj;
43659 fail:
43660 return NULL;
43661 }
43662
43663
43664 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43665 PyObject *resultobj;
43666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43667 size_t arg2 ;
43668 wxGBSpan *arg3 = 0 ;
43669 bool result;
43670 wxGBSpan temp3 ;
43671 PyObject * obj0 = 0 ;
43672 PyObject * obj1 = 0 ;
43673 PyObject * obj2 = 0 ;
43674
43675 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43677 if (SWIG_arg_fail(1)) SWIG_fail;
43678 {
43679 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43680 if (SWIG_arg_fail(2)) SWIG_fail;
43681 }
43682 {
43683 arg3 = &temp3;
43684 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43685 }
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43689
43690 wxPyEndAllowThreads(__tstate);
43691 if (PyErr_Occurred()) SWIG_fail;
43692 }
43693 {
43694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43695 }
43696 return resultobj;
43697 fail:
43698 return NULL;
43699 }
43700
43701
43702 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43703 int argc;
43704 PyObject *argv[4];
43705 int ii;
43706
43707 argc = PyObject_Length(args);
43708 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43709 argv[ii] = PyTuple_GetItem(args,ii);
43710 }
43711 if (argc == 3) {
43712 int _v;
43713 {
43714 void *ptr;
43715 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43716 _v = 0;
43717 PyErr_Clear();
43718 } else {
43719 _v = 1;
43720 }
43721 }
43722 if (_v) {
43723 {
43724 void *ptr;
43725 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43726 _v = 0;
43727 PyErr_Clear();
43728 } else {
43729 _v = 1;
43730 }
43731 }
43732 if (_v) {
43733 {
43734 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43735 }
43736 if (_v) {
43737 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43738 }
43739 }
43740 }
43741 }
43742 if (argc == 3) {
43743 int _v;
43744 {
43745 void *ptr;
43746 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43747 _v = 0;
43748 PyErr_Clear();
43749 } else {
43750 _v = 1;
43751 }
43752 }
43753 if (_v) {
43754 {
43755 void *ptr;
43756 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43757 _v = 0;
43758 PyErr_Clear();
43759 } else {
43760 _v = 1;
43761 }
43762 }
43763 if (_v) {
43764 {
43765 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43766 }
43767 if (_v) {
43768 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43769 }
43770 }
43771 }
43772 }
43773 if (argc == 3) {
43774 int _v;
43775 {
43776 void *ptr;
43777 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43778 _v = 0;
43779 PyErr_Clear();
43780 } else {
43781 _v = 1;
43782 }
43783 }
43784 if (_v) {
43785 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43786 if (_v) {
43787 {
43788 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43789 }
43790 if (_v) {
43791 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43792 }
43793 }
43794 }
43795 }
43796
43797 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43798 return NULL;
43799 }
43800
43801
43802 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43803 PyObject *resultobj;
43804 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43805 wxWindow *arg2 = (wxWindow *) 0 ;
43806 wxGBSizerItem *result;
43807 PyObject * obj0 = 0 ;
43808 PyObject * obj1 = 0 ;
43809
43810 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43812 if (SWIG_arg_fail(1)) SWIG_fail;
43813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43814 if (SWIG_arg_fail(2)) SWIG_fail;
43815 {
43816 PyThreadState* __tstate = wxPyBeginAllowThreads();
43817 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43818
43819 wxPyEndAllowThreads(__tstate);
43820 if (PyErr_Occurred()) SWIG_fail;
43821 }
43822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43823 return resultobj;
43824 fail:
43825 return NULL;
43826 }
43827
43828
43829 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43830 PyObject *resultobj;
43831 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43832 wxSizer *arg2 = (wxSizer *) 0 ;
43833 wxGBSizerItem *result;
43834 PyObject * obj0 = 0 ;
43835 PyObject * obj1 = 0 ;
43836
43837 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43839 if (SWIG_arg_fail(1)) SWIG_fail;
43840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43841 if (SWIG_arg_fail(2)) SWIG_fail;
43842 {
43843 PyThreadState* __tstate = wxPyBeginAllowThreads();
43844 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43845
43846 wxPyEndAllowThreads(__tstate);
43847 if (PyErr_Occurred()) SWIG_fail;
43848 }
43849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43850 return resultobj;
43851 fail:
43852 return NULL;
43853 }
43854
43855
43856 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43857 int argc;
43858 PyObject *argv[3];
43859 int ii;
43860
43861 argc = PyObject_Length(args);
43862 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43863 argv[ii] = PyTuple_GetItem(args,ii);
43864 }
43865 if (argc == 2) {
43866 int _v;
43867 {
43868 void *ptr;
43869 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43870 _v = 0;
43871 PyErr_Clear();
43872 } else {
43873 _v = 1;
43874 }
43875 }
43876 if (_v) {
43877 {
43878 void *ptr;
43879 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43880 _v = 0;
43881 PyErr_Clear();
43882 } else {
43883 _v = 1;
43884 }
43885 }
43886 if (_v) {
43887 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43888 }
43889 }
43890 }
43891 if (argc == 2) {
43892 int _v;
43893 {
43894 void *ptr;
43895 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43896 _v = 0;
43897 PyErr_Clear();
43898 } else {
43899 _v = 1;
43900 }
43901 }
43902 if (_v) {
43903 {
43904 void *ptr;
43905 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43906 _v = 0;
43907 PyErr_Clear();
43908 } else {
43909 _v = 1;
43910 }
43911 }
43912 if (_v) {
43913 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43914 }
43915 }
43916 }
43917
43918 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43919 return NULL;
43920 }
43921
43922
43923 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43924 PyObject *resultobj;
43925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43926 wxGBPosition *arg2 = 0 ;
43927 wxGBSizerItem *result;
43928 wxGBPosition temp2 ;
43929 PyObject * obj0 = 0 ;
43930 PyObject * obj1 = 0 ;
43931 char *kwnames[] = {
43932 (char *) "self",(char *) "pos", NULL
43933 };
43934
43935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43937 if (SWIG_arg_fail(1)) SWIG_fail;
43938 {
43939 arg2 = &temp2;
43940 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43941 }
43942 {
43943 PyThreadState* __tstate = wxPyBeginAllowThreads();
43944 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43945
43946 wxPyEndAllowThreads(__tstate);
43947 if (PyErr_Occurred()) SWIG_fail;
43948 }
43949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43950 return resultobj;
43951 fail:
43952 return NULL;
43953 }
43954
43955
43956 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43957 PyObject *resultobj;
43958 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43959 wxPoint *arg2 = 0 ;
43960 wxGBSizerItem *result;
43961 wxPoint temp2 ;
43962 PyObject * obj0 = 0 ;
43963 PyObject * obj1 = 0 ;
43964 char *kwnames[] = {
43965 (char *) "self",(char *) "pt", NULL
43966 };
43967
43968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43970 if (SWIG_arg_fail(1)) SWIG_fail;
43971 {
43972 arg2 = &temp2;
43973 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43974 }
43975 {
43976 PyThreadState* __tstate = wxPyBeginAllowThreads();
43977 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43978
43979 wxPyEndAllowThreads(__tstate);
43980 if (PyErr_Occurred()) SWIG_fail;
43981 }
43982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43983 return resultobj;
43984 fail:
43985 return NULL;
43986 }
43987
43988
43989 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43990 PyObject *resultobj;
43991 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43992 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43993 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43994 bool result;
43995 PyObject * obj0 = 0 ;
43996 PyObject * obj1 = 0 ;
43997 PyObject * obj2 = 0 ;
43998 char *kwnames[] = {
43999 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44000 };
44001
44002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44004 if (SWIG_arg_fail(1)) SWIG_fail;
44005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44006 if (SWIG_arg_fail(2)) SWIG_fail;
44007 if (obj2) {
44008 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44009 if (SWIG_arg_fail(3)) SWIG_fail;
44010 }
44011 {
44012 PyThreadState* __tstate = wxPyBeginAllowThreads();
44013 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44014
44015 wxPyEndAllowThreads(__tstate);
44016 if (PyErr_Occurred()) SWIG_fail;
44017 }
44018 {
44019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44020 }
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44028 PyObject *resultobj;
44029 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44030 wxGBPosition *arg2 = 0 ;
44031 wxGBSpan *arg3 = 0 ;
44032 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44033 bool result;
44034 wxGBPosition temp2 ;
44035 wxGBSpan temp3 ;
44036 PyObject * obj0 = 0 ;
44037 PyObject * obj1 = 0 ;
44038 PyObject * obj2 = 0 ;
44039 PyObject * obj3 = 0 ;
44040 char *kwnames[] = {
44041 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44042 };
44043
44044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44046 if (SWIG_arg_fail(1)) SWIG_fail;
44047 {
44048 arg2 = &temp2;
44049 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44050 }
44051 {
44052 arg3 = &temp3;
44053 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44054 }
44055 if (obj3) {
44056 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44057 if (SWIG_arg_fail(4)) SWIG_fail;
44058 }
44059 {
44060 PyThreadState* __tstate = wxPyBeginAllowThreads();
44061 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44062
44063 wxPyEndAllowThreads(__tstate);
44064 if (PyErr_Occurred()) SWIG_fail;
44065 }
44066 {
44067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44068 }
44069 return resultobj;
44070 fail:
44071 return NULL;
44072 }
44073
44074
44075 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44076 PyObject *obj;
44077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44078 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44079 Py_INCREF(obj);
44080 return Py_BuildValue((char *)"");
44081 }
44082 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44083 PyObject *resultobj;
44084 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44085 wxRelationship arg2 ;
44086 wxWindow *arg3 = (wxWindow *) 0 ;
44087 wxEdge arg4 ;
44088 int arg5 = (int) 0 ;
44089 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44090 PyObject * obj0 = 0 ;
44091 PyObject * obj1 = 0 ;
44092 PyObject * obj2 = 0 ;
44093 PyObject * obj3 = 0 ;
44094 PyObject * obj4 = 0 ;
44095 PyObject * obj5 = 0 ;
44096 char *kwnames[] = {
44097 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44098 };
44099
44100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44102 if (SWIG_arg_fail(1)) SWIG_fail;
44103 {
44104 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44105 if (SWIG_arg_fail(2)) SWIG_fail;
44106 }
44107 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44108 if (SWIG_arg_fail(3)) SWIG_fail;
44109 {
44110 arg4 = (wxEdge)(SWIG_As_int(obj3));
44111 if (SWIG_arg_fail(4)) SWIG_fail;
44112 }
44113 if (obj4) {
44114 {
44115 arg5 = (int)(SWIG_As_int(obj4));
44116 if (SWIG_arg_fail(5)) SWIG_fail;
44117 }
44118 }
44119 if (obj5) {
44120 {
44121 arg6 = (int)(SWIG_As_int(obj5));
44122 if (SWIG_arg_fail(6)) SWIG_fail;
44123 }
44124 }
44125 {
44126 PyThreadState* __tstate = wxPyBeginAllowThreads();
44127 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44128
44129 wxPyEndAllowThreads(__tstate);
44130 if (PyErr_Occurred()) SWIG_fail;
44131 }
44132 Py_INCREF(Py_None); resultobj = Py_None;
44133 return resultobj;
44134 fail:
44135 return NULL;
44136 }
44137
44138
44139 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44140 PyObject *resultobj;
44141 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44142 wxWindow *arg2 = (wxWindow *) 0 ;
44143 int arg3 = (int) 0 ;
44144 PyObject * obj0 = 0 ;
44145 PyObject * obj1 = 0 ;
44146 PyObject * obj2 = 0 ;
44147 char *kwnames[] = {
44148 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44149 };
44150
44151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44153 if (SWIG_arg_fail(1)) SWIG_fail;
44154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44155 if (SWIG_arg_fail(2)) SWIG_fail;
44156 if (obj2) {
44157 {
44158 arg3 = (int)(SWIG_As_int(obj2));
44159 if (SWIG_arg_fail(3)) SWIG_fail;
44160 }
44161 }
44162 {
44163 PyThreadState* __tstate = wxPyBeginAllowThreads();
44164 (arg1)->LeftOf(arg2,arg3);
44165
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 Py_INCREF(Py_None); resultobj = Py_None;
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44177 PyObject *resultobj;
44178 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44179 wxWindow *arg2 = (wxWindow *) 0 ;
44180 int arg3 = (int) 0 ;
44181 PyObject * obj0 = 0 ;
44182 PyObject * obj1 = 0 ;
44183 PyObject * obj2 = 0 ;
44184 char *kwnames[] = {
44185 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44186 };
44187
44188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44190 if (SWIG_arg_fail(1)) SWIG_fail;
44191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44192 if (SWIG_arg_fail(2)) SWIG_fail;
44193 if (obj2) {
44194 {
44195 arg3 = (int)(SWIG_As_int(obj2));
44196 if (SWIG_arg_fail(3)) SWIG_fail;
44197 }
44198 }
44199 {
44200 PyThreadState* __tstate = wxPyBeginAllowThreads();
44201 (arg1)->RightOf(arg2,arg3);
44202
44203 wxPyEndAllowThreads(__tstate);
44204 if (PyErr_Occurred()) SWIG_fail;
44205 }
44206 Py_INCREF(Py_None); resultobj = Py_None;
44207 return resultobj;
44208 fail:
44209 return NULL;
44210 }
44211
44212
44213 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44214 PyObject *resultobj;
44215 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44216 wxWindow *arg2 = (wxWindow *) 0 ;
44217 int arg3 = (int) 0 ;
44218 PyObject * obj0 = 0 ;
44219 PyObject * obj1 = 0 ;
44220 PyObject * obj2 = 0 ;
44221 char *kwnames[] = {
44222 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44223 };
44224
44225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44227 if (SWIG_arg_fail(1)) SWIG_fail;
44228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44229 if (SWIG_arg_fail(2)) SWIG_fail;
44230 if (obj2) {
44231 {
44232 arg3 = (int)(SWIG_As_int(obj2));
44233 if (SWIG_arg_fail(3)) SWIG_fail;
44234 }
44235 }
44236 {
44237 PyThreadState* __tstate = wxPyBeginAllowThreads();
44238 (arg1)->Above(arg2,arg3);
44239
44240 wxPyEndAllowThreads(__tstate);
44241 if (PyErr_Occurred()) SWIG_fail;
44242 }
44243 Py_INCREF(Py_None); resultobj = Py_None;
44244 return resultobj;
44245 fail:
44246 return NULL;
44247 }
44248
44249
44250 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44251 PyObject *resultobj;
44252 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44253 wxWindow *arg2 = (wxWindow *) 0 ;
44254 int arg3 = (int) 0 ;
44255 PyObject * obj0 = 0 ;
44256 PyObject * obj1 = 0 ;
44257 PyObject * obj2 = 0 ;
44258 char *kwnames[] = {
44259 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44260 };
44261
44262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44264 if (SWIG_arg_fail(1)) SWIG_fail;
44265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44266 if (SWIG_arg_fail(2)) SWIG_fail;
44267 if (obj2) {
44268 {
44269 arg3 = (int)(SWIG_As_int(obj2));
44270 if (SWIG_arg_fail(3)) SWIG_fail;
44271 }
44272 }
44273 {
44274 PyThreadState* __tstate = wxPyBeginAllowThreads();
44275 (arg1)->Below(arg2,arg3);
44276
44277 wxPyEndAllowThreads(__tstate);
44278 if (PyErr_Occurred()) SWIG_fail;
44279 }
44280 Py_INCREF(Py_None); resultobj = Py_None;
44281 return resultobj;
44282 fail:
44283 return NULL;
44284 }
44285
44286
44287 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44288 PyObject *resultobj;
44289 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44290 wxWindow *arg2 = (wxWindow *) 0 ;
44291 wxEdge arg3 ;
44292 int arg4 = (int) 0 ;
44293 PyObject * obj0 = 0 ;
44294 PyObject * obj1 = 0 ;
44295 PyObject * obj2 = 0 ;
44296 PyObject * obj3 = 0 ;
44297 char *kwnames[] = {
44298 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44299 };
44300
44301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44303 if (SWIG_arg_fail(1)) SWIG_fail;
44304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44305 if (SWIG_arg_fail(2)) SWIG_fail;
44306 {
44307 arg3 = (wxEdge)(SWIG_As_int(obj2));
44308 if (SWIG_arg_fail(3)) SWIG_fail;
44309 }
44310 if (obj3) {
44311 {
44312 arg4 = (int)(SWIG_As_int(obj3));
44313 if (SWIG_arg_fail(4)) SWIG_fail;
44314 }
44315 }
44316 {
44317 PyThreadState* __tstate = wxPyBeginAllowThreads();
44318 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44319
44320 wxPyEndAllowThreads(__tstate);
44321 if (PyErr_Occurred()) SWIG_fail;
44322 }
44323 Py_INCREF(Py_None); resultobj = Py_None;
44324 return resultobj;
44325 fail:
44326 return NULL;
44327 }
44328
44329
44330 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44331 PyObject *resultobj;
44332 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44333 wxWindow *arg2 = (wxWindow *) 0 ;
44334 wxEdge arg3 ;
44335 int arg4 ;
44336 PyObject * obj0 = 0 ;
44337 PyObject * obj1 = 0 ;
44338 PyObject * obj2 = 0 ;
44339 PyObject * obj3 = 0 ;
44340 char *kwnames[] = {
44341 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44342 };
44343
44344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44346 if (SWIG_arg_fail(1)) SWIG_fail;
44347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44348 if (SWIG_arg_fail(2)) SWIG_fail;
44349 {
44350 arg3 = (wxEdge)(SWIG_As_int(obj2));
44351 if (SWIG_arg_fail(3)) SWIG_fail;
44352 }
44353 {
44354 arg4 = (int)(SWIG_As_int(obj3));
44355 if (SWIG_arg_fail(4)) SWIG_fail;
44356 }
44357 {
44358 PyThreadState* __tstate = wxPyBeginAllowThreads();
44359 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44360
44361 wxPyEndAllowThreads(__tstate);
44362 if (PyErr_Occurred()) SWIG_fail;
44363 }
44364 Py_INCREF(Py_None); resultobj = Py_None;
44365 return resultobj;
44366 fail:
44367 return NULL;
44368 }
44369
44370
44371 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44372 PyObject *resultobj;
44373 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44374 int arg2 ;
44375 PyObject * obj0 = 0 ;
44376 PyObject * obj1 = 0 ;
44377 char *kwnames[] = {
44378 (char *) "self",(char *) "val", NULL
44379 };
44380
44381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44383 if (SWIG_arg_fail(1)) SWIG_fail;
44384 {
44385 arg2 = (int)(SWIG_As_int(obj1));
44386 if (SWIG_arg_fail(2)) SWIG_fail;
44387 }
44388 {
44389 PyThreadState* __tstate = wxPyBeginAllowThreads();
44390 (arg1)->Absolute(arg2);
44391
44392 wxPyEndAllowThreads(__tstate);
44393 if (PyErr_Occurred()) SWIG_fail;
44394 }
44395 Py_INCREF(Py_None); resultobj = Py_None;
44396 return resultobj;
44397 fail:
44398 return NULL;
44399 }
44400
44401
44402 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44403 PyObject *resultobj;
44404 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44405 PyObject * obj0 = 0 ;
44406 char *kwnames[] = {
44407 (char *) "self", NULL
44408 };
44409
44410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44412 if (SWIG_arg_fail(1)) SWIG_fail;
44413 {
44414 PyThreadState* __tstate = wxPyBeginAllowThreads();
44415 (arg1)->Unconstrained();
44416
44417 wxPyEndAllowThreads(__tstate);
44418 if (PyErr_Occurred()) SWIG_fail;
44419 }
44420 Py_INCREF(Py_None); resultobj = Py_None;
44421 return resultobj;
44422 fail:
44423 return NULL;
44424 }
44425
44426
44427 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44428 PyObject *resultobj;
44429 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44430 PyObject * obj0 = 0 ;
44431 char *kwnames[] = {
44432 (char *) "self", NULL
44433 };
44434
44435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44437 if (SWIG_arg_fail(1)) SWIG_fail;
44438 {
44439 PyThreadState* __tstate = wxPyBeginAllowThreads();
44440 (arg1)->AsIs();
44441
44442 wxPyEndAllowThreads(__tstate);
44443 if (PyErr_Occurred()) SWIG_fail;
44444 }
44445 Py_INCREF(Py_None); resultobj = Py_None;
44446 return resultobj;
44447 fail:
44448 return NULL;
44449 }
44450
44451
44452 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44453 PyObject *resultobj;
44454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44455 wxWindow *result;
44456 PyObject * obj0 = 0 ;
44457 char *kwnames[] = {
44458 (char *) "self", NULL
44459 };
44460
44461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44463 if (SWIG_arg_fail(1)) SWIG_fail;
44464 {
44465 PyThreadState* __tstate = wxPyBeginAllowThreads();
44466 result = (wxWindow *)(arg1)->GetOtherWindow();
44467
44468 wxPyEndAllowThreads(__tstate);
44469 if (PyErr_Occurred()) SWIG_fail;
44470 }
44471 {
44472 resultobj = wxPyMake_wxObject(result, 0);
44473 }
44474 return resultobj;
44475 fail:
44476 return NULL;
44477 }
44478
44479
44480 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44481 PyObject *resultobj;
44482 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44483 wxEdge result;
44484 PyObject * obj0 = 0 ;
44485 char *kwnames[] = {
44486 (char *) "self", NULL
44487 };
44488
44489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44491 if (SWIG_arg_fail(1)) SWIG_fail;
44492 {
44493 PyThreadState* __tstate = wxPyBeginAllowThreads();
44494 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44495
44496 wxPyEndAllowThreads(__tstate);
44497 if (PyErr_Occurred()) SWIG_fail;
44498 }
44499 resultobj = SWIG_From_int((result));
44500 return resultobj;
44501 fail:
44502 return NULL;
44503 }
44504
44505
44506 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44507 PyObject *resultobj;
44508 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44509 wxEdge arg2 ;
44510 PyObject * obj0 = 0 ;
44511 PyObject * obj1 = 0 ;
44512 char *kwnames[] = {
44513 (char *) "self",(char *) "which", NULL
44514 };
44515
44516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44518 if (SWIG_arg_fail(1)) SWIG_fail;
44519 {
44520 arg2 = (wxEdge)(SWIG_As_int(obj1));
44521 if (SWIG_arg_fail(2)) SWIG_fail;
44522 }
44523 {
44524 PyThreadState* __tstate = wxPyBeginAllowThreads();
44525 (arg1)->SetEdge((wxEdge )arg2);
44526
44527 wxPyEndAllowThreads(__tstate);
44528 if (PyErr_Occurred()) SWIG_fail;
44529 }
44530 Py_INCREF(Py_None); resultobj = Py_None;
44531 return resultobj;
44532 fail:
44533 return NULL;
44534 }
44535
44536
44537 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44538 PyObject *resultobj;
44539 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44540 int arg2 ;
44541 PyObject * obj0 = 0 ;
44542 PyObject * obj1 = 0 ;
44543 char *kwnames[] = {
44544 (char *) "self",(char *) "v", NULL
44545 };
44546
44547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44549 if (SWIG_arg_fail(1)) SWIG_fail;
44550 {
44551 arg2 = (int)(SWIG_As_int(obj1));
44552 if (SWIG_arg_fail(2)) SWIG_fail;
44553 }
44554 {
44555 PyThreadState* __tstate = wxPyBeginAllowThreads();
44556 (arg1)->SetValue(arg2);
44557
44558 wxPyEndAllowThreads(__tstate);
44559 if (PyErr_Occurred()) SWIG_fail;
44560 }
44561 Py_INCREF(Py_None); resultobj = Py_None;
44562 return resultobj;
44563 fail:
44564 return NULL;
44565 }
44566
44567
44568 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44569 PyObject *resultobj;
44570 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44571 int result;
44572 PyObject * obj0 = 0 ;
44573 char *kwnames[] = {
44574 (char *) "self", NULL
44575 };
44576
44577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44579 if (SWIG_arg_fail(1)) SWIG_fail;
44580 {
44581 PyThreadState* __tstate = wxPyBeginAllowThreads();
44582 result = (int)(arg1)->GetMargin();
44583
44584 wxPyEndAllowThreads(__tstate);
44585 if (PyErr_Occurred()) SWIG_fail;
44586 }
44587 {
44588 resultobj = SWIG_From_int((int)(result));
44589 }
44590 return resultobj;
44591 fail:
44592 return NULL;
44593 }
44594
44595
44596 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44597 PyObject *resultobj;
44598 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44599 int arg2 ;
44600 PyObject * obj0 = 0 ;
44601 PyObject * obj1 = 0 ;
44602 char *kwnames[] = {
44603 (char *) "self",(char *) "m", NULL
44604 };
44605
44606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44608 if (SWIG_arg_fail(1)) SWIG_fail;
44609 {
44610 arg2 = (int)(SWIG_As_int(obj1));
44611 if (SWIG_arg_fail(2)) SWIG_fail;
44612 }
44613 {
44614 PyThreadState* __tstate = wxPyBeginAllowThreads();
44615 (arg1)->SetMargin(arg2);
44616
44617 wxPyEndAllowThreads(__tstate);
44618 if (PyErr_Occurred()) SWIG_fail;
44619 }
44620 Py_INCREF(Py_None); resultobj = Py_None;
44621 return resultobj;
44622 fail:
44623 return NULL;
44624 }
44625
44626
44627 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44628 PyObject *resultobj;
44629 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44630 int result;
44631 PyObject * obj0 = 0 ;
44632 char *kwnames[] = {
44633 (char *) "self", NULL
44634 };
44635
44636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44638 if (SWIG_arg_fail(1)) SWIG_fail;
44639 {
44640 PyThreadState* __tstate = wxPyBeginAllowThreads();
44641 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44642
44643 wxPyEndAllowThreads(__tstate);
44644 if (PyErr_Occurred()) SWIG_fail;
44645 }
44646 {
44647 resultobj = SWIG_From_int((int)(result));
44648 }
44649 return resultobj;
44650 fail:
44651 return NULL;
44652 }
44653
44654
44655 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44656 PyObject *resultobj;
44657 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44658 int result;
44659 PyObject * obj0 = 0 ;
44660 char *kwnames[] = {
44661 (char *) "self", NULL
44662 };
44663
44664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44666 if (SWIG_arg_fail(1)) SWIG_fail;
44667 {
44668 PyThreadState* __tstate = wxPyBeginAllowThreads();
44669 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44670
44671 wxPyEndAllowThreads(__tstate);
44672 if (PyErr_Occurred()) SWIG_fail;
44673 }
44674 {
44675 resultobj = SWIG_From_int((int)(result));
44676 }
44677 return resultobj;
44678 fail:
44679 return NULL;
44680 }
44681
44682
44683 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44684 PyObject *resultobj;
44685 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44686 int result;
44687 PyObject * obj0 = 0 ;
44688 char *kwnames[] = {
44689 (char *) "self", NULL
44690 };
44691
44692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44694 if (SWIG_arg_fail(1)) SWIG_fail;
44695 {
44696 PyThreadState* __tstate = wxPyBeginAllowThreads();
44697 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44698
44699 wxPyEndAllowThreads(__tstate);
44700 if (PyErr_Occurred()) SWIG_fail;
44701 }
44702 {
44703 resultobj = SWIG_From_int((int)(result));
44704 }
44705 return resultobj;
44706 fail:
44707 return NULL;
44708 }
44709
44710
44711 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44712 PyObject *resultobj;
44713 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44714 bool result;
44715 PyObject * obj0 = 0 ;
44716 char *kwnames[] = {
44717 (char *) "self", NULL
44718 };
44719
44720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44722 if (SWIG_arg_fail(1)) SWIG_fail;
44723 {
44724 PyThreadState* __tstate = wxPyBeginAllowThreads();
44725 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44726
44727 wxPyEndAllowThreads(__tstate);
44728 if (PyErr_Occurred()) SWIG_fail;
44729 }
44730 {
44731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44732 }
44733 return resultobj;
44734 fail:
44735 return NULL;
44736 }
44737
44738
44739 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44740 PyObject *resultobj;
44741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44742 bool arg2 ;
44743 PyObject * obj0 = 0 ;
44744 PyObject * obj1 = 0 ;
44745 char *kwnames[] = {
44746 (char *) "self",(char *) "d", NULL
44747 };
44748
44749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44751 if (SWIG_arg_fail(1)) SWIG_fail;
44752 {
44753 arg2 = (bool)(SWIG_As_bool(obj1));
44754 if (SWIG_arg_fail(2)) SWIG_fail;
44755 }
44756 {
44757 PyThreadState* __tstate = wxPyBeginAllowThreads();
44758 (arg1)->SetDone(arg2);
44759
44760 wxPyEndAllowThreads(__tstate);
44761 if (PyErr_Occurred()) SWIG_fail;
44762 }
44763 Py_INCREF(Py_None); resultobj = Py_None;
44764 return resultobj;
44765 fail:
44766 return NULL;
44767 }
44768
44769
44770 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44771 PyObject *resultobj;
44772 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44773 wxRelationship result;
44774 PyObject * obj0 = 0 ;
44775 char *kwnames[] = {
44776 (char *) "self", NULL
44777 };
44778
44779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44781 if (SWIG_arg_fail(1)) SWIG_fail;
44782 {
44783 PyThreadState* __tstate = wxPyBeginAllowThreads();
44784 result = (wxRelationship)(arg1)->GetRelationship();
44785
44786 wxPyEndAllowThreads(__tstate);
44787 if (PyErr_Occurred()) SWIG_fail;
44788 }
44789 resultobj = SWIG_From_int((result));
44790 return resultobj;
44791 fail:
44792 return NULL;
44793 }
44794
44795
44796 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44797 PyObject *resultobj;
44798 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44799 wxRelationship arg2 ;
44800 PyObject * obj0 = 0 ;
44801 PyObject * obj1 = 0 ;
44802 char *kwnames[] = {
44803 (char *) "self",(char *) "r", NULL
44804 };
44805
44806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44808 if (SWIG_arg_fail(1)) SWIG_fail;
44809 {
44810 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44811 if (SWIG_arg_fail(2)) SWIG_fail;
44812 }
44813 {
44814 PyThreadState* __tstate = wxPyBeginAllowThreads();
44815 (arg1)->SetRelationship((wxRelationship )arg2);
44816
44817 wxPyEndAllowThreads(__tstate);
44818 if (PyErr_Occurred()) SWIG_fail;
44819 }
44820 Py_INCREF(Py_None); resultobj = Py_None;
44821 return resultobj;
44822 fail:
44823 return NULL;
44824 }
44825
44826
44827 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44828 PyObject *resultobj;
44829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44830 wxWindow *arg2 = (wxWindow *) 0 ;
44831 bool result;
44832 PyObject * obj0 = 0 ;
44833 PyObject * obj1 = 0 ;
44834 char *kwnames[] = {
44835 (char *) "self",(char *) "otherW", NULL
44836 };
44837
44838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44840 if (SWIG_arg_fail(1)) SWIG_fail;
44841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44842 if (SWIG_arg_fail(2)) SWIG_fail;
44843 {
44844 PyThreadState* __tstate = wxPyBeginAllowThreads();
44845 result = (bool)(arg1)->ResetIfWin(arg2);
44846
44847 wxPyEndAllowThreads(__tstate);
44848 if (PyErr_Occurred()) SWIG_fail;
44849 }
44850 {
44851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44852 }
44853 return resultobj;
44854 fail:
44855 return NULL;
44856 }
44857
44858
44859 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44860 PyObject *resultobj;
44861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44862 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44863 wxWindow *arg3 = (wxWindow *) 0 ;
44864 bool result;
44865 PyObject * obj0 = 0 ;
44866 PyObject * obj1 = 0 ;
44867 PyObject * obj2 = 0 ;
44868 char *kwnames[] = {
44869 (char *) "self",(char *) "constraints",(char *) "win", NULL
44870 };
44871
44872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44874 if (SWIG_arg_fail(1)) SWIG_fail;
44875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44876 if (SWIG_arg_fail(2)) SWIG_fail;
44877 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44878 if (SWIG_arg_fail(3)) SWIG_fail;
44879 {
44880 PyThreadState* __tstate = wxPyBeginAllowThreads();
44881 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44882
44883 wxPyEndAllowThreads(__tstate);
44884 if (PyErr_Occurred()) SWIG_fail;
44885 }
44886 {
44887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44888 }
44889 return resultobj;
44890 fail:
44891 return NULL;
44892 }
44893
44894
44895 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44896 PyObject *resultobj;
44897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44898 wxEdge arg2 ;
44899 wxWindow *arg3 = (wxWindow *) 0 ;
44900 wxWindow *arg4 = (wxWindow *) 0 ;
44901 int result;
44902 PyObject * obj0 = 0 ;
44903 PyObject * obj1 = 0 ;
44904 PyObject * obj2 = 0 ;
44905 PyObject * obj3 = 0 ;
44906 char *kwnames[] = {
44907 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44908 };
44909
44910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44912 if (SWIG_arg_fail(1)) SWIG_fail;
44913 {
44914 arg2 = (wxEdge)(SWIG_As_int(obj1));
44915 if (SWIG_arg_fail(2)) SWIG_fail;
44916 }
44917 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44918 if (SWIG_arg_fail(3)) SWIG_fail;
44919 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44920 if (SWIG_arg_fail(4)) SWIG_fail;
44921 {
44922 PyThreadState* __tstate = wxPyBeginAllowThreads();
44923 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44924
44925 wxPyEndAllowThreads(__tstate);
44926 if (PyErr_Occurred()) SWIG_fail;
44927 }
44928 {
44929 resultobj = SWIG_From_int((int)(result));
44930 }
44931 return resultobj;
44932 fail:
44933 return NULL;
44934 }
44935
44936
44937 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44938 PyObject *obj;
44939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44940 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44941 Py_INCREF(obj);
44942 return Py_BuildValue((char *)"");
44943 }
44944 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44945 PyObject *resultobj;
44946 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44947 wxIndividualLayoutConstraint *result;
44948 PyObject * obj0 = 0 ;
44949 char *kwnames[] = {
44950 (char *) "self", NULL
44951 };
44952
44953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44955 if (SWIG_arg_fail(1)) SWIG_fail;
44956 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44957
44958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44959 return resultobj;
44960 fail:
44961 return NULL;
44962 }
44963
44964
44965 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44966 PyObject *resultobj;
44967 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44968 wxIndividualLayoutConstraint *result;
44969 PyObject * obj0 = 0 ;
44970 char *kwnames[] = {
44971 (char *) "self", NULL
44972 };
44973
44974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44976 if (SWIG_arg_fail(1)) SWIG_fail;
44977 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44978
44979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44980 return resultobj;
44981 fail:
44982 return NULL;
44983 }
44984
44985
44986 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44987 PyObject *resultobj;
44988 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44989 wxIndividualLayoutConstraint *result;
44990 PyObject * obj0 = 0 ;
44991 char *kwnames[] = {
44992 (char *) "self", NULL
44993 };
44994
44995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44997 if (SWIG_arg_fail(1)) SWIG_fail;
44998 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44999
45000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45001 return resultobj;
45002 fail:
45003 return NULL;
45004 }
45005
45006
45007 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45008 PyObject *resultobj;
45009 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45010 wxIndividualLayoutConstraint *result;
45011 PyObject * obj0 = 0 ;
45012 char *kwnames[] = {
45013 (char *) "self", NULL
45014 };
45015
45016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45018 if (SWIG_arg_fail(1)) SWIG_fail;
45019 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45020
45021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45022 return resultobj;
45023 fail:
45024 return NULL;
45025 }
45026
45027
45028 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45029 PyObject *resultobj;
45030 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45031 wxIndividualLayoutConstraint *result;
45032 PyObject * obj0 = 0 ;
45033 char *kwnames[] = {
45034 (char *) "self", NULL
45035 };
45036
45037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45039 if (SWIG_arg_fail(1)) SWIG_fail;
45040 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45041
45042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45043 return resultobj;
45044 fail:
45045 return NULL;
45046 }
45047
45048
45049 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45050 PyObject *resultobj;
45051 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45052 wxIndividualLayoutConstraint *result;
45053 PyObject * obj0 = 0 ;
45054 char *kwnames[] = {
45055 (char *) "self", NULL
45056 };
45057
45058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45060 if (SWIG_arg_fail(1)) SWIG_fail;
45061 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45062
45063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45064 return resultobj;
45065 fail:
45066 return NULL;
45067 }
45068
45069
45070 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45071 PyObject *resultobj;
45072 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45073 wxIndividualLayoutConstraint *result;
45074 PyObject * obj0 = 0 ;
45075 char *kwnames[] = {
45076 (char *) "self", NULL
45077 };
45078
45079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45081 if (SWIG_arg_fail(1)) SWIG_fail;
45082 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45083
45084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45085 return resultobj;
45086 fail:
45087 return NULL;
45088 }
45089
45090
45091 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45092 PyObject *resultobj;
45093 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45094 wxIndividualLayoutConstraint *result;
45095 PyObject * obj0 = 0 ;
45096 char *kwnames[] = {
45097 (char *) "self", NULL
45098 };
45099
45100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45102 if (SWIG_arg_fail(1)) SWIG_fail;
45103 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45104
45105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45106 return resultobj;
45107 fail:
45108 return NULL;
45109 }
45110
45111
45112 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45113 PyObject *resultobj;
45114 wxLayoutConstraints *result;
45115 char *kwnames[] = {
45116 NULL
45117 };
45118
45119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45120 {
45121 PyThreadState* __tstate = wxPyBeginAllowThreads();
45122 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45123
45124 wxPyEndAllowThreads(__tstate);
45125 if (PyErr_Occurred()) SWIG_fail;
45126 }
45127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45128 return resultobj;
45129 fail:
45130 return NULL;
45131 }
45132
45133
45134 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45135 PyObject *resultobj;
45136 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45137 wxWindow *arg2 = (wxWindow *) 0 ;
45138 int *arg3 = (int *) 0 ;
45139 bool result;
45140 int temp3 ;
45141 int res3 = 0 ;
45142 PyObject * obj0 = 0 ;
45143 PyObject * obj1 = 0 ;
45144 char *kwnames[] = {
45145 (char *) "self",(char *) "win", NULL
45146 };
45147
45148 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45151 if (SWIG_arg_fail(1)) SWIG_fail;
45152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45153 if (SWIG_arg_fail(2)) SWIG_fail;
45154 {
45155 PyThreadState* __tstate = wxPyBeginAllowThreads();
45156 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45157
45158 wxPyEndAllowThreads(__tstate);
45159 if (PyErr_Occurred()) SWIG_fail;
45160 }
45161 {
45162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45163 }
45164 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45165 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45166 return resultobj;
45167 fail:
45168 return NULL;
45169 }
45170
45171
45172 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45173 PyObject *resultobj;
45174 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45175 bool result;
45176 PyObject * obj0 = 0 ;
45177 char *kwnames[] = {
45178 (char *) "self", NULL
45179 };
45180
45181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45183 if (SWIG_arg_fail(1)) SWIG_fail;
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45187
45188 wxPyEndAllowThreads(__tstate);
45189 if (PyErr_Occurred()) SWIG_fail;
45190 }
45191 {
45192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45193 }
45194 return resultobj;
45195 fail:
45196 return NULL;
45197 }
45198
45199
45200 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45201 PyObject *obj;
45202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45203 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45204 Py_INCREF(obj);
45205 return Py_BuildValue((char *)"");
45206 }
45207 static PyMethodDef SwigMethods[] = {
45208 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45209 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45210 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45213 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45234 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45247 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45262 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45316 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45344 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45363 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45365 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45373 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45374 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45386 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45398 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45402 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45408 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45418 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45428 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45435 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45514 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45516 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45518 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45520 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45522 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45524 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45526 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45528 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45530 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45532 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45534 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45536 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45538 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45552 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45570 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45573 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45576 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45588 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45593 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45599 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45605 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45668 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45675 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45711 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45721 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45727 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45729 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45731 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45734 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45738 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45741 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45744 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45746 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45751 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45759 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45763 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45766 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45768 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45772 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45789 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45791 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45794 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45796 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45800 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45804 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45815 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45818 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45821 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45825 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45832 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45837 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45842 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45846 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45891 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45911 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45918 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45922 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45932 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46104 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46144 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46158 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46161 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46216 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46243 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46287 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46295 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46314 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46315 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46352 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46382 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46385 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46389 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46392 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46402 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46414 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46426 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46436 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46446 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46460 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46467 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46468 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46469 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46470 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46471 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46476 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46503 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46515 { NULL, NULL, 0, NULL }
46516 };
46517
46518
46519 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46520
46521 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46522 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46523 }
46524 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46525 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46526 }
46527 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46528 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46529 }
46530 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46531 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46532 }
46533 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46534 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46535 }
46536 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46537 return (void *)((wxSizer *) ((wxGridSizer *) x));
46538 }
46539 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46540 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46541 }
46542 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46543 return (void *)((wxSizer *) ((wxPySizer *) x));
46544 }
46545 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46546 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46547 }
46548 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46549 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46550 }
46551 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46552 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46553 }
46554 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46555 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46556 }
46557 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46558 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46559 }
46560 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46561 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46562 }
46563 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46564 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46565 }
46566 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46567 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46568 }
46569 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46570 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46571 }
46572 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46573 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46574 }
46575 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46576 return (void *)((wxEvent *) ((wxPyEvent *) x));
46577 }
46578 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46579 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46580 }
46581 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46582 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46583 }
46584 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46585 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46586 }
46587 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46588 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46589 }
46590 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46591 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46592 }
46593 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46594 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46595 }
46596 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46597 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46598 }
46599 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46600 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46601 }
46602 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46603 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46604 }
46605 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46606 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46607 }
46608 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46609 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46610 }
46611 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46612 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46613 }
46614 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46615 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46616 }
46617 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46618 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46619 }
46620 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46621 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46622 }
46623 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46624 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46625 }
46626 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46627 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46628 }
46629 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46630 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46631 }
46632 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46633 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46634 }
46635 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46636 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46637 }
46638 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46639 return (void *)((wxEvent *) ((wxShowEvent *) x));
46640 }
46641 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46642 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46643 }
46644 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46645 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46646 }
46647 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46648 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46649 }
46650 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46651 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46652 }
46653 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46654 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46655 }
46656 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46657 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46658 }
46659 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46660 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46661 }
46662 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46663 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46664 }
46665 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46666 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46667 }
46668 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46669 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46670 }
46671 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46672 return (void *)((wxControl *) ((wxControlWithItems *) x));
46673 }
46674 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46675 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46676 }
46677 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46678 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46679 }
46680 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46681 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46682 }
46683 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46684 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46685 }
46686 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46687 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46688 }
46689 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46690 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46691 }
46692 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46693 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46694 }
46695 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46696 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46697 }
46698 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46699 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46700 }
46701 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46702 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46703 }
46704 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46705 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46706 }
46707 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46708 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46709 }
46710 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46711 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46712 }
46713 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46714 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46715 }
46716 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46717 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46718 }
46719 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46720 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46721 }
46722 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46723 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46724 }
46725 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46726 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46727 }
46728 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46729 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46730 }
46731 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46732 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46733 }
46734 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46735 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46736 }
46737 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46738 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46739 }
46740 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46741 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46742 }
46743 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46744 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46745 }
46746 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46747 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46748 }
46749 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46750 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46751 }
46752 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46753 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46754 }
46755 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46756 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46757 }
46758 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46759 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46760 }
46761 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46762 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46763 }
46764 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46765 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46766 }
46767 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46768 return (void *)((wxObject *) ((wxSizerItem *) x));
46769 }
46770 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46771 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46772 }
46773 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46774 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46775 }
46776 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46777 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46778 }
46779 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46780 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46781 }
46782 static void *_p_wxSizerTo_p_wxObject(void *x) {
46783 return (void *)((wxObject *) ((wxSizer *) x));
46784 }
46785 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46786 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46787 }
46788 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46789 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46790 }
46791 static void *_p_wxEventTo_p_wxObject(void *x) {
46792 return (void *)((wxObject *) ((wxEvent *) x));
46793 }
46794 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46795 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46796 }
46797 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46798 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46799 }
46800 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46801 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46802 }
46803 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46804 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46805 }
46806 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46807 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46808 }
46809 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46810 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46811 }
46812 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46813 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46814 }
46815 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46816 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46817 }
46818 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46819 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46820 }
46821 static void *_p_wxControlTo_p_wxObject(void *x) {
46822 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46823 }
46824 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46825 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46826 }
46827 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46828 return (void *)((wxObject *) ((wxFSFile *) x));
46829 }
46830 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46831 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46832 }
46833 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46834 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46835 }
46836 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46837 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46838 }
46839 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46840 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46841 }
46842 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46843 return (void *)((wxObject *) ((wxMenuItem *) x));
46844 }
46845 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46846 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46847 }
46848 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46849 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46850 }
46851 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46852 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46853 }
46854 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46855 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46856 }
46857 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46858 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46859 }
46860 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46861 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46862 }
46863 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46864 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46865 }
46866 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46867 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46868 }
46869 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46870 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46871 }
46872 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46873 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46874 }
46875 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46876 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46877 }
46878 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46879 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46880 }
46881 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46882 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46883 }
46884 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46885 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46886 }
46887 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46888 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46889 }
46890 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46891 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46892 }
46893 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46894 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46895 }
46896 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46897 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46898 }
46899 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46900 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46901 }
46902 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46903 return (void *)((wxObject *) ((wxImageHandler *) x));
46904 }
46905 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46906 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46907 }
46908 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46909 return (void *)((wxObject *) ((wxEvtHandler *) x));
46910 }
46911 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46912 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46913 }
46914 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46915 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46916 }
46917 static void *_p_wxImageTo_p_wxObject(void *x) {
46918 return (void *)((wxObject *) ((wxImage *) x));
46919 }
46920 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46921 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46922 }
46923 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46924 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46925 }
46926 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46927 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46928 }
46929 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46930 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46931 }
46932 static void *_p_wxWindowTo_p_wxObject(void *x) {
46933 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46934 }
46935 static void *_p_wxMenuTo_p_wxObject(void *x) {
46936 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46937 }
46938 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46939 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46940 }
46941 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46942 return (void *)((wxObject *) ((wxFileSystem *) x));
46943 }
46944 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46945 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46946 }
46947 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46948 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46949 }
46950 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46951 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46952 }
46953 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46954 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46955 }
46956 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46957 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46958 }
46959 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46960 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46961 }
46962 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46963 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46964 }
46965 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46966 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46967 }
46968 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46969 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46970 }
46971 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46972 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46973 }
46974 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46975 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46976 }
46977 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46978 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46979 }
46980 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46981 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46982 }
46983 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46984 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46985 }
46986 static void *_p_wxControlTo_p_wxWindow(void *x) {
46987 return (void *)((wxWindow *) ((wxControl *) x));
46988 }
46989 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46990 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46991 }
46992 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46993 return (void *)((wxWindow *) ((wxMenuBar *) x));
46994 }
46995 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46996 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46997 }
46998 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46999 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47000 }
47001 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47002 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47003 }
47004 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47005 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47006 }
47007 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47008 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47009 }
47010 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47011 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47012 }
47013 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47014 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47015 }
47016 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47017 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47018 }
47019 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47020 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47021 }
47022 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47023 return (void *)((wxValidator *) ((wxPyValidator *) x));
47024 }
47025 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}};
47026 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}};
47027 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}};
47028 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}};
47029 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}};
47030 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}};
47031 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}};
47032 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}};
47033 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}};
47034 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}};
47035 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}};
47036 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}};
47037 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}};
47038 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}};
47039 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47040 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}};
47041 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}};
47042 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}};
47043 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}};
47044 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}};
47045 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}};
47046 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}};
47047 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}};
47048 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}};
47049 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}};
47050 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}};
47051 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}};
47052 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}};
47053 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}};
47054 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}};
47055 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}};
47056 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}};
47057 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}};
47058 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}};
47059 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}};
47060 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}};
47061 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}};
47062 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}};
47063 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}};
47064 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}};
47065 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}};
47066 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}};
47067 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}};
47068 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}};
47069 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}};
47070 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}};
47071 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}};
47072 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}};
47073 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}};
47074 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}};
47075 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}};
47076 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}};
47077 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}};
47078 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}};
47079 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}};
47080 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}};
47081 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}};
47082 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}};
47083 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}};
47084 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}};
47085 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}};
47086 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}};
47087 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}};
47088 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}};
47089 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}};
47090 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}};
47091 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}};
47092 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}};
47093 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}};
47094 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}};
47095 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}};
47096 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}};
47097 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}};
47098 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}};
47099 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}};
47100 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}};
47101 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}};
47102 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}};
47103 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}};
47104 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}};
47105 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}};
47106 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}};
47107 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}};
47108 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}};
47109 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}};
47110 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}};
47111 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}};
47112 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}};
47113 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}};
47114 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}};
47115 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}};
47116 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}};
47117 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}};
47118 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}};
47119 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}};
47120 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}};
47121 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}};
47122 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}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47138 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}};
47139 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}};
47140 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}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153
47154 static swig_type_info *swig_types_initial[] = {
47155 _swigt__p_wxLayoutConstraints,
47156 _swigt__p_wxRealPoint,
47157 _swigt__p_wxSizerItem,
47158 _swigt__p_wxGBSizerItem,
47159 _swigt__p_wxScrollEvent,
47160 _swigt__p_wxEventLoop,
47161 _swigt__p_wxIndividualLayoutConstraint,
47162 _swigt__p_wxSizer,
47163 _swigt__p_wxBoxSizer,
47164 _swigt__p_wxStaticBoxSizer,
47165 _swigt__p_wxGridBagSizer,
47166 _swigt__p_wxAcceleratorEntry,
47167 _swigt__p_wxUpdateUIEvent,
47168 _swigt__p_wxEvent,
47169 _swigt__p_buffer,
47170 _swigt__p_wxMenu,
47171 _swigt__p_wxGridSizer,
47172 _swigt__p_wxFlexGridSizer,
47173 _swigt__p_wxInitDialogEvent,
47174 _swigt__p_wxItemContainer,
47175 _swigt__p_wxNcPaintEvent,
47176 _swigt__p_wxPaintEvent,
47177 _swigt__p_wxSysColourChangedEvent,
47178 _swigt__p_wxMouseCaptureChangedEvent,
47179 _swigt__p_wxDisplayChangedEvent,
47180 _swigt__p_wxPaletteChangedEvent,
47181 _swigt__p_wxControl,
47182 _swigt__p_wxFont,
47183 _swigt__p_wxMenuBarBase,
47184 _swigt__p_wxSetCursorEvent,
47185 _swigt__p_wxFSFile,
47186 _swigt__p_wxCaret,
47187 _swigt__ptrdiff_t,
47188 _swigt__std__ptrdiff_t,
47189 _swigt__p_wxRegion,
47190 _swigt__p_wxPoint2D,
47191 _swigt__p_int,
47192 _swigt__p_wxSize,
47193 _swigt__p_wxDC,
47194 _swigt__p_wxPySizer,
47195 _swigt__p_wxVisualAttributes,
47196 _swigt__p_wxNotifyEvent,
47197 _swigt__p_wxPyEvent,
47198 _swigt__p_wxPropagationDisabler,
47199 _swigt__p_form_ops_t,
47200 _swigt__p_wxAppTraits,
47201 _swigt__p_wxArrayString,
47202 _swigt__p_wxShowEvent,
47203 _swigt__p_wxToolTip,
47204 _swigt__p_wxMoveEvent,
47205 _swigt__p_wxSizeEvent,
47206 _swigt__p_wxActivateEvent,
47207 _swigt__p_wxIconizeEvent,
47208 _swigt__p_wxMaximizeEvent,
47209 _swigt__p_wxQueryNewPaletteEvent,
47210 _swigt__p_wxWindowCreateEvent,
47211 _swigt__p_wxIdleEvent,
47212 _swigt__p_wxDateEvent,
47213 _swigt__p_wxMenuItem,
47214 _swigt__p_wxStaticBox,
47215 _swigt__p_long,
47216 _swigt__p_wxDuplexMode,
47217 _swigt__p_wxTIFFHandler,
47218 _swigt__p_wxXPMHandler,
47219 _swigt__p_wxPNMHandler,
47220 _swigt__p_wxJPEGHandler,
47221 _swigt__p_wxPCXHandler,
47222 _swigt__p_wxGIFHandler,
47223 _swigt__p_wxPNGHandler,
47224 _swigt__p_wxANIHandler,
47225 _swigt__p_wxMemoryFSHandler,
47226 _swigt__p_wxZipFSHandler,
47227 _swigt__p_wxInternetFSHandler,
47228 _swigt__p_wxPyFileSystemHandler,
47229 _swigt__p_wxEvtHandler,
47230 _swigt__p_wxCURHandler,
47231 _swigt__p_wxICOHandler,
47232 _swigt__p_wxBMPHandler,
47233 _swigt__p_wxImageHandler,
47234 _swigt__p_wxFileSystemHandler,
47235 _swigt__p_wxRect,
47236 _swigt__p_wxButton,
47237 _swigt__p_wxGBSpan,
47238 _swigt__p_wxPropagateOnce,
47239 _swigt__p_wxAcceleratorTable,
47240 _swigt__p_wxStdDialogButtonSizer,
47241 _swigt__p_char,
47242 _swigt__p_wxGBPosition,
47243 _swigt__p_wxImage,
47244 _swigt__p_wxFrame,
47245 _swigt__p_wxScrollWinEvent,
47246 _swigt__p_wxPaperSize,
47247 _swigt__p_wxImageHistogram,
47248 _swigt__p_wxPoint,
47249 _swigt__p_wxCursor,
47250 _swigt__p_wxObject,
47251 _swigt__p_wxInputStream,
47252 _swigt__p_wxOutputStream,
47253 _swigt__p_wxPyInputStream,
47254 _swigt__p_wxDateTime,
47255 _swigt__p_wxKeyEvent,
47256 _swigt__p_wxNavigationKeyEvent,
47257 _swigt__p_wxWindowDestroyEvent,
47258 _swigt__p_unsigned_long,
47259 _swigt__p_wxWindow,
47260 _swigt__p_wxMenuBar,
47261 _swigt__p_wxFileSystem,
47262 _swigt__p_wxBitmap,
47263 _swigt__unsigned_int,
47264 _swigt__p_unsigned_int,
47265 _swigt__p_wxMenuEvent,
47266 _swigt__p_wxContextMenuEvent,
47267 _swigt__p_unsigned_char,
47268 _swigt__p_wxEraseEvent,
47269 _swigt__p_wxMouseEvent,
47270 _swigt__p_wxCloseEvent,
47271 _swigt__p_wxPyApp,
47272 _swigt__p_wxCommandEvent,
47273 _swigt__p_wxPyCommandEvent,
47274 _swigt__p_wxPyDropTarget,
47275 _swigt__p_wxQuantize,
47276 _swigt__p_wxFocusEvent,
47277 _swigt__p_wxChildFocusEvent,
47278 _swigt__p_wxDropFilesEvent,
47279 _swigt__p_wxControlWithItems,
47280 _swigt__p_wxColour,
47281 _swigt__p_wxValidator,
47282 _swigt__p_wxPyValidator,
47283 0
47284 };
47285
47286
47287 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47288
47289 static swig_const_info swig_const_table[] = {
47290 {0, 0, 0, 0.0, 0, 0}};
47291
47292 #ifdef __cplusplus
47293 }
47294 #endif
47295
47296
47297 #ifdef __cplusplus
47298 extern "C" {
47299 #endif
47300
47301 /* Python-specific SWIG API */
47302 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47303 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47304 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47305
47306 /* -----------------------------------------------------------------------------
47307 * global variable support code.
47308 * ----------------------------------------------------------------------------- */
47309
47310 typedef struct swig_globalvar {
47311 char *name; /* Name of global variable */
47312 PyObject *(*get_attr)(); /* Return the current value */
47313 int (*set_attr)(PyObject *); /* Set the value */
47314 struct swig_globalvar *next;
47315 } swig_globalvar;
47316
47317 typedef struct swig_varlinkobject {
47318 PyObject_HEAD
47319 swig_globalvar *vars;
47320 } swig_varlinkobject;
47321
47322 static PyObject *
47323 swig_varlink_repr(swig_varlinkobject *v) {
47324 v = v;
47325 return PyString_FromString("<Swig global variables>");
47326 }
47327
47328 static int
47329 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47330 swig_globalvar *var;
47331 flags = flags;
47332 fprintf(fp,"Swig global variables { ");
47333 for (var = v->vars; var; var=var->next) {
47334 fprintf(fp,"%s", var->name);
47335 if (var->next) fprintf(fp,", ");
47336 }
47337 fprintf(fp," }\n");
47338 return 0;
47339 }
47340
47341 static PyObject *
47342 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47343 swig_globalvar *var = v->vars;
47344 while (var) {
47345 if (strcmp(var->name,n) == 0) {
47346 return (*var->get_attr)();
47347 }
47348 var = var->next;
47349 }
47350 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47351 return NULL;
47352 }
47353
47354 static int
47355 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47356 swig_globalvar *var = v->vars;
47357 while (var) {
47358 if (strcmp(var->name,n) == 0) {
47359 return (*var->set_attr)(p);
47360 }
47361 var = var->next;
47362 }
47363 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47364 return 1;
47365 }
47366
47367 static PyTypeObject varlinktype = {
47368 PyObject_HEAD_INIT(0)
47369 0, /* Number of items in variable part (ob_size) */
47370 (char *)"swigvarlink", /* Type name (tp_name) */
47371 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47372 0, /* Itemsize (tp_itemsize) */
47373 0, /* Deallocator (tp_dealloc) */
47374 (printfunc) swig_varlink_print, /* Print (tp_print) */
47375 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47376 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47377 0, /* tp_compare */
47378 (reprfunc) swig_varlink_repr, /* tp_repr */
47379 0, /* tp_as_number */
47380 0, /* tp_as_sequence */
47381 0, /* tp_as_mapping */
47382 0, /* tp_hash */
47383 0, /* tp_call */
47384 0, /* tp_str */
47385 0, /* tp_getattro */
47386 0, /* tp_setattro */
47387 0, /* tp_as_buffer */
47388 0, /* tp_flags */
47389 0, /* tp_doc */
47390 #if PY_VERSION_HEX >= 0x02000000
47391 0, /* tp_traverse */
47392 0, /* tp_clear */
47393 #endif
47394 #if PY_VERSION_HEX >= 0x02010000
47395 0, /* tp_richcompare */
47396 0, /* tp_weaklistoffset */
47397 #endif
47398 #if PY_VERSION_HEX >= 0x02020000
47399 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47400 #endif
47401 #if PY_VERSION_HEX >= 0x02030000
47402 0, /* tp_del */
47403 #endif
47404 #ifdef COUNT_ALLOCS
47405 0,0,0,0 /* tp_alloc -> tp_next */
47406 #endif
47407 };
47408
47409 /* Create a variable linking object for use later */
47410 static PyObject *
47411 SWIG_Python_newvarlink(void) {
47412 swig_varlinkobject *result = 0;
47413 result = PyMem_NEW(swig_varlinkobject,1);
47414 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47415 result->ob_type = &varlinktype;
47416 result->vars = 0;
47417 result->ob_refcnt = 0;
47418 Py_XINCREF((PyObject *) result);
47419 return ((PyObject*) result);
47420 }
47421
47422 static void
47423 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47424 swig_varlinkobject *v;
47425 swig_globalvar *gv;
47426 v= (swig_varlinkobject *) p;
47427 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47428 gv->name = (char *) malloc(strlen(name)+1);
47429 strcpy(gv->name,name);
47430 gv->get_attr = get_attr;
47431 gv->set_attr = set_attr;
47432 gv->next = v->vars;
47433 v->vars = gv;
47434 }
47435
47436 /* -----------------------------------------------------------------------------
47437 * constants/methods manipulation
47438 * ----------------------------------------------------------------------------- */
47439
47440 /* Install Constants */
47441 static void
47442 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47443 PyObject *obj = 0;
47444 size_t i;
47445 for (i = 0; constants[i].type; i++) {
47446 switch(constants[i].type) {
47447 case SWIG_PY_INT:
47448 obj = PyInt_FromLong(constants[i].lvalue);
47449 break;
47450 case SWIG_PY_FLOAT:
47451 obj = PyFloat_FromDouble(constants[i].dvalue);
47452 break;
47453 case SWIG_PY_STRING:
47454 if (constants[i].pvalue) {
47455 obj = PyString_FromString((char *) constants[i].pvalue);
47456 } else {
47457 Py_INCREF(Py_None);
47458 obj = Py_None;
47459 }
47460 break;
47461 case SWIG_PY_POINTER:
47462 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47463 break;
47464 case SWIG_PY_BINARY:
47465 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47466 break;
47467 default:
47468 obj = 0;
47469 break;
47470 }
47471 if (obj) {
47472 PyDict_SetItemString(d,constants[i].name,obj);
47473 Py_DECREF(obj);
47474 }
47475 }
47476 }
47477
47478 /* -----------------------------------------------------------------------------*/
47479 /* Fix SwigMethods to carry the callback ptrs when needed */
47480 /* -----------------------------------------------------------------------------*/
47481
47482 static void
47483 SWIG_Python_FixMethods(PyMethodDef *methods,
47484 swig_const_info *const_table,
47485 swig_type_info **types,
47486 swig_type_info **types_initial) {
47487 size_t i;
47488 for (i = 0; methods[i].ml_name; ++i) {
47489 char *c = methods[i].ml_doc;
47490 if (c && (c = strstr(c, "swig_ptr: "))) {
47491 int j;
47492 swig_const_info *ci = 0;
47493 char *name = c + 10;
47494 for (j = 0; const_table[j].type; j++) {
47495 if (strncmp(const_table[j].name, name,
47496 strlen(const_table[j].name)) == 0) {
47497 ci = &(const_table[j]);
47498 break;
47499 }
47500 }
47501 if (ci) {
47502 size_t shift = (ci->ptype) - types;
47503 swig_type_info *ty = types_initial[shift];
47504 size_t ldoc = (c - methods[i].ml_doc);
47505 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47506 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47507 char *buff = ndoc;
47508 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47509 strncpy(buff, methods[i].ml_doc, ldoc);
47510 buff += ldoc;
47511 strncpy(buff, "swig_ptr: ", 10);
47512 buff += 10;
47513 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47514 methods[i].ml_doc = ndoc;
47515 }
47516 }
47517 }
47518 }
47519
47520 /* -----------------------------------------------------------------------------*
47521 * Initialize type list
47522 * -----------------------------------------------------------------------------*/
47523
47524 #if PY_MAJOR_VERSION < 2
47525 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47526 is copied out of Python/modsupport.c in python version 2.3.4 */
47527 static int
47528 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47529 {
47530 PyObject *dict;
47531 if (!PyModule_Check(m)) {
47532 PyErr_SetString(PyExc_TypeError,
47533 "PyModule_AddObject() needs module as first arg");
47534 return -1;
47535 }
47536 if (!o) {
47537 PyErr_SetString(PyExc_TypeError,
47538 "PyModule_AddObject() needs non-NULL value");
47539 return -1;
47540 }
47541
47542 dict = PyModule_GetDict(m);
47543 if (dict == NULL) {
47544 /* Internal error -- modules must have a dict! */
47545 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47546 PyModule_GetName(m));
47547 return -1;
47548 }
47549 if (PyDict_SetItemString(dict, name, o))
47550 return -1;
47551 Py_DECREF(o);
47552 return 0;
47553 }
47554 #endif
47555
47556 static swig_type_info **
47557 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47558 static PyMethodDef swig_empty_runtime_method_table[] = {
47559 {
47560 NULL, NULL, 0, NULL
47561 }
47562 };/* Sentinel */
47563
47564 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47565 swig_empty_runtime_method_table);
47566 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47567 if (pointer && module) {
47568 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47569 }
47570 return type_list_handle;
47571 }
47572
47573 static swig_type_info **
47574 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47575 swig_type_info **type_pointer;
47576
47577 /* first check if module already created */
47578 type_pointer = SWIG_Python_GetTypeListHandle();
47579 if (type_pointer) {
47580 return type_pointer;
47581 } else {
47582 /* create a new module and variable */
47583 return SWIG_Python_SetTypeListHandle(type_list_handle);
47584 }
47585 }
47586
47587 #ifdef __cplusplus
47588 }
47589 #endif
47590
47591 /* -----------------------------------------------------------------------------*
47592 * Partial Init method
47593 * -----------------------------------------------------------------------------*/
47594
47595 #ifdef SWIG_LINK_RUNTIME
47596 #ifdef __cplusplus
47597 extern "C"
47598 #endif
47599 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47600 #endif
47601
47602 #ifdef __cplusplus
47603 extern "C"
47604 #endif
47605 SWIGEXPORT(void) SWIG_init(void) {
47606 static PyObject *SWIG_globals = 0;
47607 static int typeinit = 0;
47608 PyObject *m, *d;
47609 int i;
47610 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47611
47612 /* Fix SwigMethods to carry the callback ptrs when needed */
47613 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47614
47615 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47616 d = PyModule_GetDict(m);
47617
47618 if (!typeinit) {
47619 #ifdef SWIG_LINK_RUNTIME
47620 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47621 #else
47622 # ifndef SWIG_STATIC_RUNTIME
47623 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47624 # endif
47625 #endif
47626 for (i = 0; swig_types_initial[i]; i++) {
47627 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47628 }
47629 typeinit = 1;
47630 }
47631 SWIG_InstallConstants(d,swig_const_table);
47632
47633
47634 #ifndef wxPyUSE_EXPORT
47635 // Make our API structure a CObject so other modules can import it
47636 // from this module.
47637 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47638 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47639 Py_XDECREF(cobj);
47640 #endif
47641
47642 {
47643 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49294 }
49295 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49296 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49297 {
49298 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49449 }
49450 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49451 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49452 {
49453 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49460 }
49461
49462 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49463
49464
49465 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49466
49467 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49468 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49469 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49470 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49471 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49472 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49473 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49474 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49475 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49476 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49477 {
49478 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49482 }
49483 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49484 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49485 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49486 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49487 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49488 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49489 {
49490 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49536 }
49537 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49538 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49539 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49540 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49541 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49542 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49543 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49544 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49545 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49546 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49547 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49548 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49549 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49550 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49551 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49552 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49553 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49554 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49555 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49556 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49557 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49558 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49559 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49560 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49561 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49562 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49563 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49564 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49565 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49566 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49567 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49568 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49569 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49570 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49571 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49572 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49573 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49574 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49575 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49576 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49577 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49578 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49579 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49580 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49581 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49582 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49583 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49584 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49585 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49586 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49587 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49588 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49589 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49590 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49591 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49592 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49593 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49594 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49595 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49596 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49597 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49598 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49599 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49600 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49601 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49602 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49603 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49604 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49605 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49606 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49607 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49608 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49609 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49610 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49611 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49612 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49613 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49614 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49615 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49616 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49617 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49618 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49619 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49620 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49621 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49622 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49623 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49624 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49625 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49626 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49627 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49628 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49629 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49630 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49631 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49632 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49633 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49634 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49635 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49636 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49637 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49638 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49639 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49640 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49641 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49642 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49643 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49644 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49645 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49646 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49647 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49648 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49649 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49650 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49651 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49652 {
49653 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49690 }
49691 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49692 {
49693 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49706 }
49707 {
49708 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49709 }
49710 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49711 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49712 {
49713 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49717 }
49718 {
49719 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49720 }
49721 {
49722 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49723 }
49724 {
49725 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49726 }
49727 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49728 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49729 {
49730 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49731 }
49732 {
49733 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49734 }
49735 {
49736 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49737 }
49738 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49739 {
49740 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49741 }
49742 {
49743 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49744 }
49745 {
49746 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49747 }
49748 {
49749 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49750 }
49751 {
49752 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49762 }
49763 {
49764 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49765 }
49766 {
49767 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49768 }
49769 {
49770 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49771 }
49772 {
49773 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49774 }
49775 {
49776 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49795 }
49796
49797 // Initialize threading, some globals and such
49798 __wxPyPreStart(d);
49799
49800
49801 // Although these are defined in __version__ they need to be here too so
49802 // that an assert can be done to ensure that the wxPython and the wxWindows
49803 // versions match.
49804 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49805 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49806 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49807
49808 }
49809
wxWidgets (Impactor)